Spring 第四篇

2023-10-09 19:20:28

Spring中的事务

1.事务回顾

事务:是逻辑上一组操作，要么全都成功，要么全都失败.

事务特性:ACID

原子性:事务不可分割

一致性:事务执行的前后，数据完整性保持一致.

隔离性:一个事务执行的时候，不应该受到其他事务的打扰

持久性:一旦结束，数据就永久的保存到数据库.

如果不考虑隔离性:

脏读:一个事务读到另一个事务未提交数据

不可重复读:一个事务读到另一个事务已经提交数据（update）导致一个事务多次查询结果不一致

虚读:一个事务读到另一个事务已经提交数据（insert）导致一个事务多次查询结果不一致

事务的隔离级别:

未提交读:以上情况都有可能发生。

已提交读:避免脏读，但不可重复读，虚读是有可能发生。

可重复读:避免脏读，不可重复读，但是虚读有可能发生。 串行的:避免以上所有情况.

2.Spring中的事务

Spring中事务管理 分层开发：事务处在Service层.

Spring提供事务管理API

PlatformTransactionManager:平台事务管理器.

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

​ TransactionDefinition:事务定义 ​ ISOLation_XXX：

事务隔离级别. ​ PROPAGATION_XXX：

事务的传播行为. ​ TransactionStatus:

事务状态 ​ 是否有保存点 ​ 是否是一个新的事务 ​ 事务是否已经提交 ​

关系:PlatformTransactionManager通过TransactionDefinition设置事务相关信息管理事务，管理事务过程中，产生一些事务状态，状态由TransactionStatus记录。

API详解: ​ PlatformTransactionManager:接口. ​ Spring为不同的持久化框架提供了不同PlatformTransactionManager接口实现

使用Spring JDBC或iBatis 进行持久化数据时使用（重点） ​ org.springframework.jdbc.datasource.DataSourceTransactionManager

使用Hibernate进行持久化数据时使用 ​ org.springframework.orm.hibernate.HibernateTransactionManager

使用JPA进行持久化时使用 ​ org.springframework.orm.jpa.JpaTransactionManager

当持久化机制是Jdo时使用 ​ org.springframework.jdo.JdoTransactionManager

使用一个JTA实现来管理事务，在一个事务跨越多个资源时必须使用 ​ org.springframework.transaction.jta.JtaTransactionManager ​ TransactionDefinition: ​ ISOLATION_DEFAULT:默认级别. Mysql --> repeatable_read | Oracle -->> read_commited

级别如下：

ISOLATION_READ_UNCOMMITTED ​

ISOLATION_READ_COMMITTED ​

ISOLATION_REPEATABLE_READ ​

ISOLATION_SERIALIZABLE

3.Sping中事务的传播行为

事务的传播行为:(不是JDBC事务管理，用来解决实际开发的问题.) 传播行为：解决业务层之间的调用的事务的关系.

PROPAGATION_REQUIRED: 支持当前事务，如果不存在 就新建一个

  • A,B 如果A有事务，B使用A的事务，如果A没有事务，B就开启一个新的事务.(A,B是在一个事务中。)

PROPAGATION_SUPPORTS: 支持当前事务，如果不存在，就不使用事务

  • A,B 如果A有事务，B使用A的事务，如果A没有事务，B就不使用事务.

PROPAGATION_MANDATORY: 支持当前事务，如果不存在，抛出异常

  • A,B 如果A有事务，B使用A的事务，如果A没有事务，抛出异常.

PROPAGATION_REQUIRES_NEW: 如果有事务存在，挂起当前事务，创建一个新的事务

  • A,B 如果A有事务，B将A的事务挂起，重新创建一个新的事务.(A,B不在一个事务中.事务互不影响.)

PROPAGATION_NOT_SUPPORTED: 以非事务方式运行，如果有事务存在，挂起当前事务

  • A,B 非事务的方式运行，A有事务，就会挂起当前的事务.

PROPAGATION_NEVER: 以非事务方式运行，如果有事务存在，抛出异常 PROPAGATION_NESTED: 如果当前事务存在，则嵌套事务执行

  • 基于SavePoint技术.

  • A,B A有事务，A执行之后，将A事务执行之后的内容保存到SavePoint.B事务有异常的话，用户需要自己设置事务提交还是回滚.

  • 常用:(重点) PROPAGATION_REQUIRED PROPAGATION_REQUIRES_NEW PROPAGATION_NESTED

4.Spring的事务管理

Spring的事务管理分成两类

编程式事务管理: ​ 手动编写代码完成事务管理.（了解）

声明式事务管理: 不需要手动编写代码,配置.

5.Spring的事务案例一（编程式事务代理）

事务操作的环境搭建

5.1创建表

CREATE TABLE `account` (
    `id` int(11) NOT NULL AUTO_INCREMENT,
    `name` varchar(20) NOT NULL,
    `money` double DEFAULT NULL,
    PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;
​
INSERT INTO `account` VALUES ('1', 'aaa', '1000');
INSERT INTO `account` VALUES ('2', 'bbb', '1000');

5.2导入依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.ayit</groupId>
    <artifactId>spring-12</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.10</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>5.3.10</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.10</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.6</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.7</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.26</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
        </dependency>
    </dependencies>


</project>

5.3 编写db.properties连接数据库配置文件（这是我自己的连接数据库的配置文件，我使用的是druid连接池）

db.username = root
db.password = 123456
db.url = jdbc:mysql://localhost:3306/contact_system?serverTimezone=Asia/Shanghai
db.driverClassName = com.mysql.cj.jdbc.Driver

5.4编写Service层

package com.qf.service;

public interface AccountService {
    //转账
    void transfer(Integer fromId,Integer toId,Double money);
}

package com.qf.service.impl;

import com.qf.mapper.AccountMapper;
import com.qf.service.AccountService;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.TransactionCallbackWithoutResult;
import org.springframework.transaction.support.TransactionTemplate;

public class AccountServiceImpl implements AccountService {

    private AccountMapper accountMapper;

    public void setAccountMapper(AccountMapper accountMapper) {
        this.accountMapper = accountMapper;
    }

    //事务模板对象
    private TransactionTemplate transactionTemplate;

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

    @Override
    public void transfer(Integer fromId, Integer toId, Double money) {

        //手动编程式事务（了解）
        transactionTemplate.execute(new TransactionCallbackWithoutResult() {
            @Override
            protected void doInTransactionWithoutResult(TransactionStatus status) {
                accountMapper.decrease(fromId,money);//转入

                //出现异常的代码
                int i = 1 / 0;
                accountMapper.increase(toId,money);//转出
            }
        });
    }
}

5.5 编写dao层（mapper）

package com.qf.mapper;

public interface AccountMapper {

    void decrease(Integer id,Double money);//转出

    void increase(Integer id,Double money);//转入
}

package com.qf.mapper.impl;

import com.qf.mapper.AccountMapper;
import org.springframework.jdbc.core.support.JdbcDaoSupport;

public class AccountMapperImpl extends JdbcDaoSupport implements AccountMapper {

    @Override
    public void decrease(Integer id, Double money) {
        getJdbcTemplate().update(
                "update account set money = money - ? where id = ?",
                money,id);
    }

    @Override
    public void increase(Integer id, Double money) {
        getJdbcTemplate().update(
                "update account set money = money + ? where id = ?",
                money,id);
    }
}

5.6 编写applicationContext.xml文件

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

    <!--引入配置文件-->
    <context:property-placeholder location="classpath:db.properties"></context:property-placeholder>

    <!--引入数据源-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="username" value="${db.username}"></property>
        <property name="password" value="${db.password}"></property>
        <property name="url" value="${db.url}"></property>
        <property name="driverClassName" value="${db.driverClassName}"></property>
    </bean>

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

    <!--事务模板对象-->
    <bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
        <property name="transactionManager" ref="transactionManager"></property>
    </bean>

    <bean id="accountMapper" class="com.qf.mapper.impl.AccountMapperImpl">
        <property name="dataSource" ref="dataSource"></property>

    </bean>

    <bean id="accountService" class="com.qf.service.impl.AccountServiceImpl">
        <property name="accountMapper" ref="accountMapper"></property>
        <property name="transactionTemplate" ref="transactionTemplate"></property>
    </bean>
</beans>

5.7 编写测试类

import com.qf.service.AccountService;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringTest {
    @Test
    public void test(){
        ClassPathXmlApplicationContext applicationContext =
                new ClassPathXmlApplicationContext("applicationContext.xml");

        AccountService accountService = (AccountService) applicationContext.getBean("accountService");
        accountService.transfer(1,2,100d);
    }
}

5.8 结果：

测试方法未执行以前，表的信息：

Spring 第四篇

在service层的AccountServiceImpl类，我手动写了一个算术异常：

Spring 第四篇

我在调用修改数据库中表的字段的方法之后，手写了一个异常，由于开启了事务，自动回滚到了没有修改的状态。

Spring 第四篇

测试方法执行后， 数据库中表的信息没有发生改变

Spring 第四篇

把异常注释掉，继续测试

Spring 第四篇 Spring 第四篇

数据库中表的信息，可以看到aaa和bbb的金额改变了

Spring 第四篇

6.Spring的事务案例二（声明式事务代理，使用XML配置AOP）

 第一种：Xml配置（aop）的方式完成事务管理

1.修改application配置文件

<?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:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       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/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--引入配置文件-->
    <context:property-placeholder location="classpath:db.properties"></context:property-placeholder>

    <!--引入数据源-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="username" value="${db.username}"></property>
        <property name="password" value="${db.password}"></property>
        <property name="url" value="${db.url}"></property>
        <property name="driverClassName" value="${db.driverClassName}"></property>
    </bean>

    <!--事务核心管理器,封装了所有事务操作. 依赖于连接池-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!--配置事务通知-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="transfer" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false"/>
            <tx:method name="find*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false"/>
        </tx:attributes>
    </tx:advice>

    <!--配置织入-->
    <aop:config>
        <!--配置切点表达式-->
        <aop:pointcut id="txPc" expression="execution(* com.ayit.service.impl.*ServiceImpl.*(..))"/>
        <!-- 配置切面 : 通知+切点 advice-ref:通知的名称 pointcut-ref:切点的名称 -->
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPc"></aop:advisor>
    </aop:config>

    <bean id="accountMapper" class="com.ayit.mapper.impl.AccountMapperImpl">
        <property name="dataSource" ref="dataSource"></property>
    </bean>


    <bean id="accountService" class="com.ayit.service.impl.AccountServiceImpl">
        <property name="accountMapper" ref="accountMapper"></property>
    </bean>

</beans>

2.修改service层中的AccountServiceImpl类

package com.ayit.service.impl;

import com.ayit.mapper.AccountMapper;
import com.ayit.service.AccountService;

public class AccountServiceImpl implements AccountService {

    private AccountMapper accountMapper;

    public void setAccountMapper(AccountMapper accountMapper) {
        this.accountMapper = accountMapper;
    }

    @Override
    public void transfer(Integer fromId, Integer toId, Double money) {
        accountMapper.decrease(fromId,money);//转出

        //出现异常的代码
        int i = 1/ 0;
        accountMapper.increase(toId,money);//转入
    }
}

 3.开始测试：

Spring 第四篇

出现异常，数据库中的信息没有发生改变（结合上一个案例）

注释异常，然后执行测试（我懒得测了，感兴趣的可以去测测）

 Spring 第四篇

总结：

    <!-- 配置事务通知 -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
    <!-- 企业中配置CRUD方法一般使用方法名+通配符*的形式配置通知，此时类中的方法名要和配置的方法名一致 -->
    <!-- 以方法为单位,指定方法应用什么事务属性
    isolation：用于指定事务的隔离级别。默认值是DEFAULT，表示使用数据库的默认隔离级别。
    propagation：用于指定事务的传播行为。默认值是REQUIRED，表示一定会有事务，增删改的选择。查询方法可以选择SUPPORTS。
    read-only：用于指定事务是否只读。只有查询方法才能设置为true。默认值是false，表示读写。
    timeout：用于指定事务的超时时间，默认值是-1，表示永不超时。如果指定了数值，以秒为单位。
    rollback-for：用于指定一个异常，当产生该异常时，事务回滚，产生其他异常时，事务不回滚。没有默认值。表示任何异常都回滚。
    no-rollback-for：用于指定一个异常，当产生该异常时，事务不回滚，产生其他异常时事务回滚。没有默认值。表示任何异常都回滚。
    -->
            <tx:method name="save*" isolation="REPEATABLE_READ"
                       propagation="REQUIRED" read-only="false" />
            <tx:method name="persist*" isolation="REPEATABLE_READ"
                       propagation="REQUIRED" read-only="false" />
            <tx:method name="update*" isolation="REPEATABLE_READ"
                       propagation="REQUIRED" read-only="false" />
            <tx:method name="modify*" isolation="REPEATABLE_READ"
                       propagation="REQUIRED" read-only="false" />
            <tx:method name="delete*" isolation="REPEATABLE_READ"
                       propagation="REQUIRED" read-only="false" />
            <tx:method name="remove*" isolation="REPEATABLE_READ"
                       propagation="REQUIRED" read-only="false" />
            <tx:method name="get*" isolation="REPEATABLE_READ"
                       propagation="REQUIRED" read-only="true" />
            <tx:method name="find*" isolation="REPEATABLE_READ"
                       propagation="REQUIRED" read-only="true" />
            <tx:method name="transfer" isolation="REPEATABLE_READ"
                       propagation="REQUIRED" read-only="false" />
        </tx:attributes>
    </tx:advice>

7.Spring的事务案例三（声明式事务代理，使用注解配置AOP）

 第一种：注解配置（aop）的方式完成事务管理

1.修改applicationContext.xml文件

<?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:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       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/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--引入配置文件-->
    <context:property-placeholder location="classpath:db.properties"></context:property-placeholder>

    <!--引入数据源-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="username" value="${db.username}"></property>
        <property name="password" value="${db.password}"></property>
        <property name="url" value="${db.url}"></property>
        <property name="driverClassName" value="${db.driverClassName}"></property>
    </bean>

    <!-- 事务核心管理器,封装了所有事务操作. 依赖于连接池 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!-- 开启spring对注解事务的支持-->
    <tx:annotation-driven></tx:annotation-driven>


    <bean id="accountMapper" class="com.qf.mapper.impl.AccountMapperImpl">
        <property name="dataSource" ref="dataSource"></property>

    </bean>

    <bean id="accountService" class="com.qf.service.impl.AccountServiceImpl">
        <property name="accountMapper" ref="accountMapper"></property>
    </bean>
</beans>

2.修改service层中的AccountServiceImpl类

package com.qf.service.impl;

import com.qf.mapper.AccountMapper;
import com.qf.service.AccountService;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

@Transactional(isolation = Isolation.DEFAULT,propagation = Propagation.REQUIRED,readOnly = true)
public class AccountServiceImpl implements AccountService {

    private AccountMapper accountMapper;

    public void setAccountMapper(AccountMapper accountMapper) {
        this.accountMapper = accountMapper;
    }

    @Override
    //如果该方法与类名上的配置不同，可以单独在这个方法上配置注解
    @Transactional(isolation = Isolation.DEFAULT,propagation = Propagation.REQUIRED,readOnly = false)
    public void transfer(Integer fromId, Integer toId, Double money) {
        // 减钱
        accountMapper.decrease(fromId,money);
        int i = 1 / 0;// 如果发生异常数据（钱）会丢失吗？
        // 加钱
        accountMapper.increase(toId,money);
    }

}

  3.开始测试：

Spring 第四篇

出现异常，数据库中的信息没有发生改变（结合上上个案例）

注释异常，然后执行测试（我懒得测了，感兴趣的可以去测测）

Spring 第四篇

上一篇：为什么TCP4次挥手时等待为2MSL？


下一篇：计算机网络-5-10-TCP运输连接管理