Spring框架从入门到入土(六)：Spring框架的事务管理

最新推荐文章于 2023-05-30 11:30:28 发布

BKSW.

最新推荐文章于 2023-05-30 11:30:28 发布

阅读量968

点赞数

分类专栏： javaweb 文章标签： spring java 事务处理

本文链接：https://blog.csdn.net/weixin_51276056/article/details/124356898

版权

javaweb 专栏收录该内容

27 篇文章 2 订阅

订阅专栏

Spring框架从入门到入土(六)：Spring框架的事务管理

什么是事务？

事务就是指一组sql语句的集合，集合中有多条sql语句可能是insert也可能是update，select，delete。我们希望这些多个sql语句都能成功或者都失败，这些sql语句的执行是一致的，作为一个整体执行。

事务处理有多种方式，存在不足

不同的数据库访问技术，处理对象的事务和方法不同，需要了解不同数据库访问技术的原理
掌握多种数据库中事务的处理逻辑，什么时候提交事务，什么时候回顾事务
处理事务的多种方法

总结：就是多种数据库的访问技术，有不同的事务处理的机制，对象和方法。

怎样解决不足？

spring提供了一种处理事务的模型，能够统一步骤，方式完成不同的数据库访问技术事务处理。

使用spring的事务处理机制，可以完成mybatis访问数据库的事务处理
使用spring的事务处理机制，可以完成hibernate访问数据库的事务处理

怎样处理事务？

spring处理事务的模型

spring处理事务的模型，使用的步骤都是固定的。把事务使用的信息提供给spring就可以了

事务内部提交，回滚事务，使用事务管理器，代替你完成commit，rollback

事务管理器是一个接口和众多的实现类。
接口:PlatformTransactionManager ，定义了事务重要方法commit ，rollback
实现类:spring把每一种数据库访问技术对应的事务处理类都创建好了。
mybatis访问数据库—spring创建好的DataSourceTransactionManager
hibernate访问数据库----spring创建的HibernateTransactionManager

怎么使用:你需要告诉spring你用是那种数据库的访问技术，怎么告诉spring呢?
声明数据库访问技术对于的事务管理器实现类，在spring的配置文件中使用<bean>声明就可以了
例如，你要使用mybatis访问数据库，你应该在xm1配置文件中
<bean id=“xxx”" class=“. . .DataSourceTransactionManager”>
你的业务方法需要什么样的事务，说明需要事务的类型。
- 事务的隔离级别:有4个值。
  DEFAULT:采用DB默认的事务隔离级别。MySql的默认为REPEATABLE_READ; Oracle默认为READ_COMMITTED.
  READ_UNCOMMITTED: 读未提交。未解决任何并发问题
  口READ_COMMITTED: 读已提交。解决脏读，存在不可重复读与幻读
  口REPEATABLE_READ: 可重复读。解决脏读、不可重复读，存在幻读
  口SERIALIZABLE: 串行化。不存在并发问题.
- 事务的超时时间：表示一个方法的最长执行时间，如果方法执行时间超过了时间，事务就回滚
  
  单位是秒，整数值，默认是-1
- 事务的传播行为：控制业务是不是有事务的，是什么样的事务的
7个传播行为，表示业务在调用的时候，事务在方法之间是如何使用的。
- PROPAGATION_ REQUIRED
- PROPAGATION_ REQUIRES_NEW
- PROPAGATION_SUPPORTS
  
  总是新建一个事务，若当前存在事务，就将当前事务挂起，直到新的事务执行完毕。
前三个需要掌握

PROPAGATION_MANDATORY
PROPAGATION_NESTED
PROPAGATION_NEVER
PROPAGATION_NOT_ SUPPORTED
事务提交事务，回滚事务的时机
- 当你的业务方法，执行成功，没有异常抛出，当方法执行完毕，spring在方法执行后提交事务。事务管理器commit
- 当你的业务方法抛出运行时异常或ERROR,spring执行回滚，调用事务管理器的rollback
  运行时异常的定义: RuntimeException 和他的子类都是运行时异常，例如Nul1PointException
- 当你的业务方法拋出非运行时异常，主要是受查异常时，提交事务
  受查异常:在你写代码中，必须处理的异常。例如IOException, SQLException

总结spring的事务

管理事务的是事务管理和他的实现类
spring的事务是一个统一模型
- 指定要使用的事务管理器实现类，使用<bean>
- 指定哪些类，哪些方法需要加入事务的功能
- 指定方法需要的隔离级别，传播行为，超时
你需要告诉spring，你的项目中的类信息，方法的名称，方法事务的传播行为

程序举例和环境搭建

创建数据库表

创建实体类

package com.liar.entity;

/**
 * @author liar
 * @date 编写时间: 2022/3/31 9:12
 */
public class Sale {
    private Integer id;
    private Integer gid;
    private Integer nums;

    public Sale() {
    }

    public Sale(Integer id, Integer gid, Integer nums) {
        this.id = id;
        this.gid = gid;
        this.nums = nums;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public Integer getGid() {
        return gid;
    }

    public void setGid(Integer gid) {
        this.gid = gid;
    }

    public Integer getNums() {
        return nums;
    }

    public void setNums(Integer nums) {
        this.nums = nums;
    }

    @Override
    public String toString() {
        return "Sale{" +
                "id=" + id +
                ", gid=" + gid +
                ", nums=" + nums +
                '}';
    }
}

package com.liar.entity;

/**
 * @author liar
 * @date 编写时间: 2022/3/31 9:14
 */
public class Goods {

    private Integer id;
    private String name;
    private Integer amount;
    private Float price;

    public Goods() {
    }

    public Goods(Integer id, String name, Integer amount, Float price) {
        this.id = id;
        this.name = name;
        this.amount = amount;
        this.price = price;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAmount() {
        return amount;
    }

    public void setAmount(Integer amount) {
        this.amount = amount;
    }

    public Float getPrice() {
        return price;
    }

    public void setPrice(Float price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Goods{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", amount=" + amount +
                ", price=" + price +
                '}';
    }
}

Dao部分接口和mapper文件

package com.liar.dao;

import com.liar.entity.Goods;

/**
 * @author liar
 * @date 编写时间: 2022/3/31 9:21
 */
public interface GoodsDao {

    /**
     * 更新库存
     * @param goods
     * @return
     */
    int updateGoods(Goods goods);

    /**
     * 查询商品信息
     * @param id
     * @return
     */
    Goods selectGoods(Integer id);
}

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.liar.dao.GoodsDao">
    <select id="selectGoods" resultType="com.liar.entity.Goods">
        select id, name, amount, price
        from goods
        where id = #{gid}
    </select>
    
    <update id="updateGoods">
        update goods set amount = amount-#{amount} where id = #{id}
    </update>

</mapper>

package com.liar.dao;

import com.liar.entity.Sale;

/**
 * @author liar
 * @date 编写时间: 2022/3/31 9:17
 */
public interface SaleDao {

    /**增加销售记录
     * @param sale
     * @return
     */
    int insertSale(Sale sale);
}

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.liar.dao.SaleDao">
    <insert id="insertSale">
        insert into sale(gid,nums)
        values (#{gid}, #{nums})
    </insert>

</mapper>

mybatis的主配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>


<!--设置别名-->
    <typeAliases>
        <package name="com.liar.entity"/>
    </typeAliases>


    <!--sql mapper（sql映射文件）的位置-->
    <mappers>
        <!--
           name是包名，是这个包中所有mapper.xml一次都能加载
        -->
        <package name="com.liar.dao"/>
    </mappers>
</configuration>

Service部分

package com.liar.service;

/**
 * @author liar
 * @date 编写时间: 2022/3/31 9:31
 */
public interface BuyGoodsService {
    /**
     * 买商品
     * @param goodsId
     * @param nums
     */
    void buy(Integer goodsId,Integer nums);
}

自定义运行时异常类

package com.liar.exception;

/**
 * 自定义运行时异常
 * @author liar
 * @date 编写时间: 2022/3/31 9:42
 */
public class NotEnoughException extends RuntimeException{

    public NotEnoughException() {
        super();
    }

    public NotEnoughException(String message) {
        super(message);
    }
}

Service实现类

package com.liar.service.impl;

import com.liar.dao.GoodsDao;
import com.liar.dao.SaleDao;
import com.liar.entity.Goods;
import com.liar.entity.Sale;
import com.liar.exception.NotEnoughException;
import com.liar.service.BuyGoodsService;

/**
 * @author liar
 * @date 编写时间: 2022/3/31 9:35
 */
public class BuyGoodsServiceImpl implements BuyGoodsService {

    private SaleDao saleDao;
    private GoodsDao goodsDao;


    @Override
    public void buy(Integer goodsId, Integer nums) {
        System.out.println("buy方法开始执行....请稍等...");
        //记录销售信息，向sale表中添加记录
        Sale sale = new Sale();
        sale.setId(goodsId);
        sale.setNums(nums);
        saleDao.insertSale(sale);

        //更新库存
        Goods goods = goodsDao.selectGoods(goodsId);
        if(goods == null){
            //商品不存在
            throw new NullPointerException("编号是："+goodsId+"的商品不存在！");
        }else if(goods.getAmount() < nums){
            //商品库存不足
            throw new NotEnoughException("编号是："+goodsId+"的商品库存不足！");
        }
        //修改库存
        Goods buyGoods = new Goods();
        buyGoods.setId(goodsId);
        buyGoods.setAmount(nums);
        goodsDao.updateGoods(buyGoods);

        System.out.println("buy方法执行结束！");

    }

    public void setSaleDao(SaleDao saleDao) {
        this.saleDao = saleDao;
    }

    public void setGoodsDao(GoodsDao goodsDao) {
        this.goodsDao = goodsDao;
    }
}

数据库配置文件properties

jdbc.url=jdbc:mysql://localhost:3306/springdb?characterEncoding=UTF8&useSSL=false
jdbc.username=root
jdbc.password=001204
jdbc.maxActive=30

spring配置文件

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


    <!--数据库的配置信息，写在一个独立的文件，编译修改配置数据库的内容
        让spring知道配置文件的位置
    -->
    <context:property-placeholder location="classpath:pool.properties"/>

    <!--声明数据源DataSource，作用是连接数据库-->
    <bean id="myDataSource" class="com.alibaba.druid.pool.DruidDataSource"
          init-method="init" destroy-method="close">
        <!--set注入给DuridDataSource提供的数据库信息-->
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="maxActive" value="${jdbc.maxActive}"/>
    </bean>

    <!--声明的是mybatis提供的SqlSessionFactory类，这个类内部创建SqlSessionFactory的-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--set注入，把数据库的连接池赋值给dataSource-->
        <property name="dataSource" ref="myDataSource"/>
        <!--主配置文件的位置
        configLocation属性是Resource类型，读取配置文件
        它的赋值，使用value,指定文件的路径，使用classpath:表示文件的位置
        -->
        <property name="configLocation" value="classpath:mybatis.xml"/>
    </bean>

    <!--创建dao对象，使用SqlSession的getMapper（StudentDao.class)
        MapperScannerConfigurer:在内部调用getMapper()生成dao接口的代理对象
    -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--指定SqlSessionFactory对象的id-->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        <!--指定包名，包名是dao接口所在的包名
            MapperScannerConfigurer会扫描这个包中的所有接口，
            把每个接口都执行一次getMapper()方法，得到每个接口的dao对象
            创建好的对象放进spring容器中
        -->
        <property name="basePackage" value="com.liar.dao"/>
    </bean>

    <!--声明service类-->
    <bean id="buyService" class="com.liar.service.impl.BuyGoodsServiceImpl">
        <property name="goodsDao" ref="goodsDao"/>
        <property name="saleDao" ref="saleDao"/>
    </bean>

</beans>

测试购买方法

package com.liar;

import com.liar.service.BuyGoodsService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author liar
 * @date 编写时间: 2022/4/6 16:17
 */
public class MyTest {

    @Test
    public void test01(){
        String config = "applicationContext.xml";
        ApplicationContext context =  new ClassPathXmlApplicationContext(config);
        //从容器中获取Service
        BuyGoodsService service = (BuyGoodsService) context.getBean("buyService");
        //调用方法
        service.buy(1001,10);
    }
}

测试结构

改进程序

spring框架中提供的事务处理方案：

适合中小型项目使用的，注解方案

spring框架自己使用aop实现给业务增加事务的功能，使用@Transactional注解增加事务。

需要声明事务管理器对象

<bean id=“xxx” class=“DataSourceTransactionManager”>
开启事务注解驱动，告诉spring框架，需要使用注解方式管理事务。

spring使用aop机制，创建@Transactional所在类的代理对象，给方法加入事务的功能。

spring给业务加入事务：

在业务方法开始执行前，先开启事务，在业务方法执行后提交或者回滚事务，使用aop环绕通知
```
@Around("你要增加的业务功能的业务方法名称")
Object myAround{
   开启事务，spring开启
   try{
     buy(1001,10);
     spring事务管理.commit();
    }catch(Exception e){
     spring事务管理.rollback();
    }
}
```
在方法上加入@Transactional

详细代码更改

在spring配置文件中加入

    <!--使用spring的事务管理-->
    <!--1. 声明事务管理器-->
    <bean id="transactionManger" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--连接数据库，指定数据源-->
        <property name="dataSource" ref="myDataSource"/>
    </bean>
    <!--2.开启事务注解驱动，告诉spring使用注解管理事务，创建代理对象
        transaction-manager:事务管理器对象
    -->
    <tx:annotation-driven transaction-manager="transactionManger"/>

在service实现类中加入注解

    @Transactional(
            propagation = Propagation.REQUIRED,
            isolation = Isolation.DEFAULT,
            readOnly = false,
            //表示发生异常一定回滚
            rollbackFor = {
                    NullPointerException.class,NotEnoughException.class
            }
    )
//真正使用的时候，直接写@Transactional就可以了，并且要写在公共方法上，不能写在私有方法上

测试错误结果

    @Test
    public void test01(){
        String config = "applicationContext.xml";
        ApplicationContext context =  new ClassPathXmlApplicationContext(config);
        //从容器中获取Service
        BuyGoodsService service = (BuyGoodsService) context.getBean("buyService");
        System.out.println("Service是代理："+service.getClass().getName());
        //调用方法
        service.buy(1005,10);
    }

spring处理事务逻辑

spring框架会首先检查方法抛出的异常是不是在rollbackFor的属性值中

如果在rollbackFor的列表中，不管是什么类型的异常，一定要回滚
如果抛出的异常不再rollbackFor的列表中，spring会判断异常是不是RuntimeException

如果是一定回滚，

使用AspectJ的AOP配置管理事务

适合大型项目，有很多的类和放大，需要大量配置事务，，使用aspectj功能，在spring配置文件中声明类，方法需要的事务，这种业务方法和事务配置完全分离。

实现步骤

都是在配置文件中实现的

要使用aspectj框架，加入依赖

    <!--spring的aop依赖-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>
  </dependencies>

声明事务管理器

声明方法需要的事务类型(配置方法的事务属性【隔离级别】、【传播行为】、【超时】)
配置aop：指定哪些类需要创建代理

具体实现

在spring配置文件中

    <!--声明式事务处理：和源代码完全分离的-->
    <!--声明事务管理器-->
    <bean id="transactionManger" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--连接数据库，指定数据源-->
        <property name="dataSource" ref="myDataSource"/>
    </bean>

    <!--声明业务方法它的事务属性【隔离级别】、【传播行为】、【超时时间】
    id:自定义名称，表示 <tx:advice >和</tx:advice>之间的内容
    transaction-manager：代表事务管理器id
    -->
    <tx:advice id="myAdvice" transaction-manager="transactionManger">
        <!--tx:attributes：表示配置事务属性-->
        <tx:attributes>
            <!--tx:method：给具体的方法配置事务属性，method可以有多个，分别给不同的方法设置事务属性
            name：方法名称 1. 完整的方法名称，不带有包和类
                         2. 可以使用通配符
            propagation：传播行为，枚举值
            isolation：隔离级别
            rollback-for：你指定的异常类名，全限定名称，发生异常一定回滚
            -->
            <tx:method name="buy" propagation="REQUIRED" isolation="DEFAULT"
                       rollback-for="java.lang.NullPointerException,com.liar.exception.NotEnoughException"/>
            <!--使用通配符，指定多个方法-->
            <tx:method name="add" propagation="REQUIRES_NEW"/>
            <!--指定修改方法-->
            <tx:method name="modify" />
            <!--指定删除方法-->
            <tx:method name="remove"/>
            <!--指定查询方法-->
            <tx:method name="*" propagation="SUPPORTS"/>
        </tx:attributes>
    </tx:advice>

    <!--    配置aop-->
    <aop:config>
        <!--配置切入点表达式：指定包中类要使用事务
        id:切入点表达式的名称，唯一值
        expression：切入点表达式，指定哪些类要使用事务，aspectj会创建代理对象
        execution(* *..service..*.*(..)):service包中的所有包中的所有类中的所有方法
        -->
        <aop:pointcut id="servicePt" expression="execution(* *..service..*.*(..))"/>
        <!--配置增强器：关联advice和pointcut
        advice-ref:通知，上面的advice的配置
        pointcut-ref：切入点表达式的id
        -->
        <aop:advisor advice-ref="myAdvice" pointcut-ref="servicePt"/>
    </aop:config>

BKSW.

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring框架从入门到入土(六)：Spring框架的事务管理

Spring框架从入门到入土(六)：Spring框架的事务管理什么是事务？事务就是指一组sql语句的集合，集合中有多条sql语句可能是insert也可能是update，select，delete。我们希望这些多个sql语句都能成功或者都失败，这些sql语句的执行是一致的，作为一个整体执行。事务处理有多种方式，存在不足不同的数据库访问技术，处理对象的事务和方法不同，需要了解不同数据库访问技术的原理掌握多种数据库中事务的处理逻辑，什么时候提交事务，什么时候回顾事务处理事务的多种方法总结：就
复制链接

扫一扫