spring事务

最新推荐文章于 2024-05-22 10:00:08 发布

Sharpen__

最新推荐文章于 2024-05-22 10:00:08 发布

阅读量414

点赞数

分类专栏： Java框架

本文链接：https://blog.csdn.net/Sharpen__/article/details/109955083

版权

Java框架专栏收录该内容

14 篇文章 0 订阅

订阅专栏

Spring 的事务管理

事务原本是数据库中的概念，在 Dao 层。但一般情况下，需要将事务提升到业务层，
即 Service 层。这样做是为了能够使用事务的特性来管理具体的业务。
在 Spring 中通常可以通过以下两种方式来实现对事务的管理：
（1）使用 Spring 的事务注解管理事务
（2）使用 AspectJ 的 AOP 配置管理事务

Spring 事务管理 API
Spring 的事务管理，主要用到两个事务相关的接口。

（1）事务管理器接口
事务管理器是 PlatformTransactionManager 接口对象。其主要用于完成事务的提交、回滚，及获取事务的状态信息。
在这里插入图片描述
A、常用的两个实现类
PlatformTransactionManager 接口有两个常用的实现类：
➢ DataSourceTransactionManager：使用 JDBC 或 MyBatis 进行数据库操作时使用。
➢ HibernateTransactionManager：使用 Hibernate 进行持久化数据时使用。

B、 Spring 的回滚方式
Spring 事务的默认回滚方式是：发生运行时异常和 error 时回滚，发生受查(编译)异常时提交。不过，对于受查异常，程序员也可以手工设置其回滚方式。

C、回顾错误与异常
在这里插入图片描述
Throwable 类是 Java 语言中所有错误或异常的超类。只有当对象是此类(或其子类之一)的实例时，才能通过 Java 虚拟机或者 Java 的 throw 语句抛出。

Error 是程序在运行过程中出现的无法处理的错误，比如 OutOfMemoryError、
ThreadDeath、NoSuchMethodError 等。当这些错误发生时，程序是无法处理（捕获或抛出）的，JVM 一般会终止线程。

程序在编译和运行时出现的另一类错误称之为异常，它是 JVM 通知程序员的一种方式。通过这种方式，让程序员知道已经或可能出现错误，要求程序员对其进行处理。

异常分为运行时异常与受查异常。
运行时异常，是 RuntimeException 类或其子类，即只有在运行时才出现的异常。如，NullPointerException、ArrayIndexOutOfBoundsException、IllegalArgumentException 等均属于运行时异常。这些异常由 JVM 抛出，在编译时不要求必须处理（捕获或抛出）。但，只要代码编写足够仔细，程序足够健壮，运行时异常是可以避免的。

受查异常，也叫编译时异常，即在代码编写时要求必须捕获或抛出的异常，若不处理，则无法通过编译。如 SQLException，ClassNotFoundException，IOException 等都属于受查异常。

RuntimeException 及其子类以外的异常，均属于受查异常。当然，用户自定义的 Exception的子类，即用户自定义的异常也属受查异常。程序员在定义异常时，只要未明确声明定义的为 RuntimeException 的子类，那么定义的就是受查异常。

（2）事务定义接口
事务定义接口 TransactionDefinition 中定义了事务描述相关的三类常量：事务隔离级别、事务传播行为、事务默认超时时限，及对它们的操作。
在这里插入图片描述
A、定义了五个事务隔离级别常量

这些常量均是以 ISOLATION_开头。即形如 ISOLATION_XXX。
➢ DEFAULT：采用 DB 默认的事务隔离级别。MySql 的默认REPEATABLE_READ； Oracle默认为 READ_COMMITTED。
➢ READ_UNCOMMITTED：读未提交。未解决任何并发问题。
➢ READ_COMMITTED：读已提交。解决脏读，存在不可重复读与幻读。
➢ REPEATABLE_READ：可重复读。解决脏读、不可重复读，存在幻读
➢ SERIALIZABLE：串行化。不存在并发问题。

B、定义了七个事务传播行为常量

所谓事务传播行为是指，处于不同事务中的方法在相互调用时，执行期间事务的维护情况。如，A 事务中的方法 doSome()调用 B 事务中的方法 doOther()，在调用执行期间事务的维护情况，就称为事务传播行为。事务传播行为是加在方法上的。
事务传播行为常量都是以 PROPAGATION_ 开头，形如 PROPAGATION_XXX。

PROPAGATION_REQUIRED
PROPAGATION_REQUIRES_NEW
PROPAGATION_SUPPORTS
//前三个用到的最多
PROPAGATION_MANDATORY 
PROPAGATION_NESTED
PROPAGATION_NEVER
PROPAGATION_NOT_SUPPORTED

a、 PROPAGATION_REQUIRED：

指定的方法必须在事务内执行。若当前存在事务，就加入到当前事务中；若当前没有事务，则创建一个新事务。这种传播行为是最常见的选择，也是 Spring 默认的事务传播行为。

如该传播行为加在 doOther()方法上。若 doSome()方法在调用 doOther()方法时就是在事务内运行的，则 doOther()方法的执行也加入到该事务内执行。若 doSome()方法在调用doOther()方法时没有在事务内执行，则 doOther()方法会创建一个事务，并在其中执行。
在这里插入图片描述
b、PROPAGATION_SUPPORTS

指定的方法支持当前事务，但若当前没有事务，也可以以非事务方式执行。
在这里插入图片描述
c、 PROPAGATION_REQUIRES_NEW

总是新建一个事务，若当前存在事务，就将当前事务挂起，直到新事务执行完毕。
在这里插入图片描述
C、定义了默认事务超时时限

常量 TIMEOUT_DEFAULT 定义了事务底层默认的超时时限，sql 语句的执行时长。
注意，事务的超时时限起作用的条件比较多，且超时的时间计算点较复杂。所以，该
值一般就使用默认值即可。

举例说明：：购买商品 trans_sale 项目，本例要实现购买商品，模拟用户下订单，向订单表添加销售记录，从商品表减少库存。

创建两个数据库表 sale , goods
sale 销售表
在这里插入图片描述

pom.xml依赖

<dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>

    <!--    spring核心ioc-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>
    <!--    做spring事务用到的-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>
    <!--    mybatis的依赖-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.1</version>
    </dependency>
    <!--    mybatis-spring两者集成的依赖-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>1.3.1</version>
    </dependency>
    <!--    mysql驱动-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.9</version>
    </dependency>
    <!--    阿里公司的数据库连接池-->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.12</version>
    </dependency>

  </dependencies>

  <build>
    <!--    目的是将src/main/java目录中的xml文件包含到输出结果中。输出到classes目录中-->
    <resources>
      <resource>
        <directory>src/main/java</directory><!--所在的目录-->
        <includes><!--包括目录下的.properties,.xml 文件都会扫描到-->
          <include>**/*.properties</include>
          <include>**/*.xml</include>
        </includes>
        <filtering>false</filtering>
      </resource>
    </resources>
    <!--    指定jdk的版本-->
    <plugins>
      <plugin>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.1</version>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
        </configuration>
      </plugin>
    </plugins>
  </build>

代码结构：
在这里插入图片描述
mybatis.xml

<?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>
    <!--这里映射的是mapper.xml文件，如果有多个mapper文件，记得修改此处-->
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>

<!--    设置别名-->
    <typeAliases>
<!--        name:实体列的所在的包名-->
        <package name="com.b204.entity"/>
    </typeAliases>
    
    <mappers>
<!--        name：是包名，这个包中的所有的mapper.xml一次都能加载-->
        <package name="com.b204.dao"/>
    </mappers>
</configuration>

使用配置文件jdbc.properties：

jdbc.url=jdbc:mysql://localhost:3306/springdb?characterEncoding=utf8
jdbc.username=root
jdbc.password=bbb
jdbc.maxActive=20

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

<!--    声明数据源DataSource，作用是连接数据库的配置内容
-->
<!--    把数据库的配置信息，写在一个独立的文件，编译-->
    <context:property-placeholder location="classpath:jdbc.properties"/>
<!--    使用属性配置文件中的数据，语法${key}-->

    <bean id="myDataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
<!--        set注入给DruidDataSource提供连接数据库信息-->
        <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中提供的SqlSessionFactoryBean类，这个类内部创建SqlSessionFactory的-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<!--        set注入，把数据库的连接池赋给了dataSource属性-->
        <property name="dataSource" ref="myDataSource"/>
<!--        mybatis主配置文件的位置
            configLocation属性是Resource类型，读取配置文件
            它的赋值 使用value，指定文件的路径，使用classpath：表示文件的位置
-->
        <property name="configLocation" value="classpath:mybatis.xml"/>
    </bean>

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

<!--    声明service-->
    <bean id="buyGoodsService" class="com.b204.service.impl.BuyGoodsServiceImpl">
        <property name="goodsDao" ref="goodsDao"/>
        <property name="saleDao" ref="saleDao"/>
    </bean>
 </beans>

接口及其对应映射文件：

public interface GoodsDao {
    //更新库存
    //goods表示本次用户购买的商品信息，id，购买的数量
    int updateGoods(Goods goods);
    //查询商品的信息
    Goods selectGoods(Integer id);
}
public interface SaleDao {
    //增加销售记录
    int inertSale(Sale sale);
}

namespace是该接口的全限定名

<?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.b204.dao.GoodsDao">
    <select id="selectGoods" resultType="com.b204.entity.Goods">
        select * from goods where id = #{gid}
    </select>

    <update id="updateGoods" >
        update goods set amount = amount -#{amount} where id=#{id}
    </update>
</mapper>

<?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.b204.dao.SaleDao">
    <insert id="inertSale">
        insert into sale(gid,nums) values(#{gid},#{nums})
    </insert>
</mapper>

实体类：

public class Goods {
    private Integer id;
    private String name;
    private Integer amount;
    private Float price;
    //getter,setter,toString()
    }

public class Sale {
    private Integer id;
    private Integer gid;
    private Integer nums;
     //getter,setter,toString()
    }

自定义商品库存不足异常：

//自定义的运行时异常
public class NotEnoughException extends RuntimeException{
    public NotEnoughException() {
    }
    public NotEnoughException(String message) {
        super(message);
    }
}

业务接口及其实现类：

public interface BuyGoodsService {
    //购买商品的方法，goodsId，购买商品的编号
    void buy(Integer goodsId,Integer nums);
}

实现类：

public class BuyGoodsServiceImpl implements BuyGoodsService {
    private GoodsDao goodsDao;
    private SaleDao saleDao;

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

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

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

        //更新库存
        Goods goods = goodsDao.selectGoods(goodsId);
        if(goods==null){
            //商品不存在
            throw new NullPointerException("编号是"+goodsId+",这个商品不存在！");
        }else if(goods.getAmount()<nums){
            //商品库存不足
            throw new NotEnoughException("编号是"+goodsId+",商品库存不足！");
        }else{
            //修改库存
            Goods buyGoods = new Goods();
            buyGoods.setId(goodsId);
            buyGoods.setAmount(nums);
            goodsDao.updateGoods(buyGoods);
        }
        System.out.println("buy方法结束");
    }

但是，如果使用这种写法，当出现异常时，销售表记录仍然会增加信息。所以，要引入事务。
修改buy方法：
在applicationContext.xm文件中添加

<!--    使用spring的事务处理，声明事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!--        需要知道连接的数据库信息-->
        <property name="dataSource" ref="myDataSource"/>
    </bean>

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

/*@Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.DEFAULT,readOnly = false,
            rollbackFor = {NullPointerException.class, NotEnoughException.class})*/
    //使用默认值，默认抛出运行时异常
    @Transactional
    @Override
    public void buy(Integer goodsId, Integer nums) {
        System.out.println("buy方法开始");
        Sale sale=new Sale();
        sale.setGid(goodsId);
        sale.setNums(nums);
        //记录销售信息，向sale表添加记录
        saleDao.inertSale(sale);

        //更新库存
        Goods goods = goodsDao.selectGoods(goodsId);
        if(goods==null){
            //商品不存在
            throw new NullPointerException("编号是"+goodsId+",这个商品不存在！");
        }else if(goods.getAmount()<nums){
            //商品库存不足
            throw new NotEnoughException("编号是"+goodsId+",商品库存不足！");
        }else{
            //修改库存
            Goods buyGoods = new Goods();
            buyGoods.setId(goodsId);
            buyGoods.setAmount(nums);
            goodsDao.updateGoods(buyGoods);
        }
        System.out.println("buy方法结束");
    }

使用 AspectJ 的 AOP 配置管理事务
使用 XML 配置事务代理的方式的不足是，每个目标类都需要配置事务代理。当目标类较多，配置文件会变得非常臃肿。
使用 XML 配置顾问方式可以自动为每个符合切入点表达式的类生成事务代理。其用法很简单，只需将前面代码中关于事务代理的配置删除，再替换为如下内容即可。
maven 依赖 pom.xml

新加入 aspectj 的依赖坐标

<dependency> 
	<groupId>org.springframework</groupId> 
	<artifactId>spring-aspects</artifactId>
	<version>5.2.5.RELEASE</version>
</dependency>

在容器中添加事务管理器
applicationContext.xml

<!--    使用spring的事务处理，声明事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!--        需要知道连接的数据库信息-->
        <property name="dataSource" ref="myDataSource"/>
    </bean>

配置事务通知
为事务通知设置相关属性。用于指定要将事务以什么方式织入给哪些方法。
例如，应用到 buy 方法上的事务要求是必须的，且当 buy 方法发生异常后要回滚业务。

<!--    2.声明业务方法它的事务属性（隔离级别，传播行为，超时时间）-->
    <tx:advice id="buyAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="buy" propagation="REQUIRED" isolation="DEFAULT" rollback-for="java.lang.NullPointerException,com.b204.excp.NotEnoughException"/>
<!--            使用通配符指定很多方法-->
<!--            添加方法-->
            <tx:method name="add*" propagation="REQUIRES_NEW"/>
<!--            删除方法-->
            <tx:method name="delete*" propagation="REQUIRES_NEW"/>
<!--            修改方法-->
            <tx:method name="modify*"/>
<!--            查询方法，query，search等方法-->
            <tx:method name="*" propagation="SUPPORTS" read-only="true"/>
        </tx:attributes>
    </tx:advice>

配置增强器
指定将配置好的事务通知，织入给谁

<!--    配置aop-->
    <aop:config>
<!--        配置切入点表达式：指定那些包中类，要使用事务-->
<!--        id:切入点表达式名称，唯一值
            expression :切入点表达式，指定哪些类要使用事务，aspectj会创建代理对象
-->
        <aop:pointcut id="servicePt" expression="execution(* *..service..*.*(..))"/>

        <!-- 配置增强器：关联advice和pointcut
            advice-ref:通知，上面tx:advice里的配置
            pointcut-ref：切入点表达式的id
        -->
        <aop:advisor advice-ref="buyAdvice" pointcut-ref="servicePt"/>
    </aop:config>

修改测试类
测试类中要从容器中获取的是目标对象

@Test
    public void test01(){
        String config= "applicationContext.xml";
        ApplicationContext ac = new ClassPathXmlApplicationContext(config);
        BuyGoodsService service = (BuyGoodsService)ac.getBean("buyAdvice");

        System.out.println("service是代理"+service.getClass().getName());
        service.buy(1001,10);
    }

Sharpen__

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
spring事务

Spring 的事务管理事务原本是数据库中的概念，在 Dao 层。但一般情况下，需要将事务提升到业务层，即 Service 层。这样做是为了能够使用事务的特性来管理具体的业务。在 Spring 中通常可以通过以下两种方式来实现对事务的管理：（1）使用 Spring 的事务注解管理事务（2）使用 AspectJ 的 AOP 配置管理事务Spring 事务管理 APISpring 的事务管理，主要用到两个事务相关的接口。（1）事务管理器接口事务管理器是 PlatformTransaction
复制链接

扫一扫