当前位置： 首页 > news >正文

Java--Spring事务

news 来源：原创 2024/5/8 3:16:12

事务原本是数据库中的概念，在Dao层。但Spring框架将事务提升到业务层，即 Service 层

Spring事务的本质其实就是数据库对事务的支持

Spring支持编程式事务管理以及声明式事务管理两种方式

一、编程式事务管理

编程式事务管理是侵入性事务管理，使用TransactionTemplate或者直接使用PlatformTransactionManager，对于编程式事务管理，Spring推荐使用TransactionTemplate

二、声明式事务管理

声明式事务管理建立在AOP之上，其本质是对方法前后进行拦截，然后在目标方法开始之前创建或者加入一个事务，执行完目标方法之后根据执行的情况提交或者回滚。

编程式事务每次实现都要单独实现，但业务量大功能复杂时，使用编程式事务无疑是痛苦的，而声明式事务不同，声明式事务属于无侵入式，不会影响业务逻辑的实现，只需要在配置文件中做相关的事务规则声明或者通过注解的方式，便可以将事务规则应用到业务逻辑中。

显然声明式事务管理要优于编程式事务管理，这正是Spring倡导的非侵入式的编程方式。唯一不足的地方就是声明式事务管理的粒度是方法级别，而编程式事务管理是可以到代码块的，但是可以通过提取方法的方式完成声明式事务管理的配置。

事务定义接口 TransactionDefinition 中定义了事务描述相关的三类常量：事务隔离级别、事务传播行为、事务默认超时时限

事务隔离级别

这些常量均是以 ISOLATION_开头。即形如 ISOLATION_XXX

1、DEFAULT：采用 DB 默认的事务隔离级别。MySql 的默认为 REPEATABLE_READ； Oracle默认为 READ_COMMITTED 

2、READ_UNCOMMITTED：读未提交。未解决任何并发问题

3、READ_COMMITTED：读已提交。解决脏读，存在不可重复读与幻读

4、REPEATABLE_READ：可重复读。解决脏读、不可重复读，存在幻读

5、SERIALIZABLE：串行化。不存在并发问题

事务传播行为

事务传播行为是指，处于不同事务中的方法在相互调用时，执行期间事务的维护情况。如，A 事务中的方法 doSome()调用 B 事务中的方法 doOther()，在调用执行期间事务的维护情况，就称为事务传播行为。事务传播行为是加在方法上的

事务传播行为常量都是以 PROPAGATION_ 开头，形如 PROPAGATION_XXX

1、PROPAGATION_REQUIRED

2、PROPAGATION_REQUIRES_NEW

3、PROPAGATION_SUPPORTS

4、PROPAGATION_MANDATORY

5、PROPAGATION_NESTED

6、PROPAGATION_NEVER

7、PROPAGATION_NOT_SUPPORTED

PROPAGATION_REQUIRED：

指定的方法必须在事务内执行。若当前存在事务，就加入到当前事务中；若当前没有事务，则创建一个新事务。这种传播行为是最常见的选择，也是 Spring 默认的事务传播行为。如该传播行为加在 doOther()方法上。若 doSome()方法在调用 doOther()方法时就是在事务内运行的，则 doOther()方法的执行也加入到该事务内执行。若 doSome()方法在调用doOther()方法时没有在事务内执行，则 doOther()方法会创建一个事务，并在其中执行

PROPAGATION_SUPPORTS

指定的方法支持当前事务，但若当前没有事务，也可以以非事务方式执行

PROPAGATION_REQUIRES_NEW

总是新建一个事务，若当前存在事务，就将当前事务挂起，直到新事务执行完毕

事务默认超时时限

表示一个方法最长的执行时间，如果方法执行时超过了时间，事务就回滚。单位是秒， 整数值， 默认是 -1

Spring事务回滚规则

Spring 事务的默认回滚方式是：发生运行时异常和 error 时回滚，发生受查(编译)异常时提交

Throwable 类是 Java 语言中所有错误或异常的超类

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

程序在编译和运行时出现的另一类错误称之为异常，它是 JVM 通知程序员的一种方式

异常分为运行时异常与受查异常

运行时异常，是 RuntimeException 类或其子类，即只有在运行时才出现的异常

NullPointerException、ArrayIndexOutOfBoundsException、IllegalArgumentException 等均属于

运行时异常。这些异常由 JVM 抛出，在编译时不要求必须处理（捕获或抛出）

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

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

事务管理器是 PlatformTransactionManager 接口对象

DataSourceTransactionManager：使用 JDBC 或 MyBatis 进行数据库操作时使用

HibernateTransactionManager：使用 Hibernate 进行持久化数据时使用

1、创建数据库，建一张商品good表和商品销售记录sale_good表

  

2、新建一个maven项目

3、加入maven的依赖

（1）spring依赖 （2）mybatis依赖 （3）mysql驱动 （4）spring的事务依赖 （5）mybatis和spring集成依赖

4、创建实体类

public class Goods {
    private Integer id;
    private String goodName;
    private Integer goodAmount;
    private Float price;

    public Integer getId() {
        return id;
    }

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

    public String getGoodName() {
        return goodName;
    }

    public void setGoodName(String goodName) {
        this.goodName = goodName;
    }

    public Integer getGoodAmount() {
        return goodAmount;
    }

    public void setGoodAmount(Integer goodAmount) {
        this.goodAmount = goodAmount;
    }

    public Float getPrice() {
        return price;
    }

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


public class Sale {
    private Integer id;
    private Integer gid;
    private Integer 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;
    }
}

5、创建dao接口和mapper文件

public interface GoodsDao {
    //更新库存
    //goods表示本次用户购买的商品信息， id， 购买数量
    int updateGoods(Goods goods);

    //查询商品的信息
    Goods selectGoods(Integer id);
}


public interface SaleDao {
    //增加销售记录
    int insertSale(Sale sale);
}

 GoodsDao.xml

<?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.xx.dao.GoodsDao">

    <resultMap id="goodMap" type="com.xx.domain.Goods">
        <id column="id" property="id" />
        <result column="good_name" property="goodName" />
        <result column="good_amount" property="goodAmount" />
        <result column="price" property="price" />
    </resultMap>

    <select id="selectGoods" resultMap="goodMap">
        select id,good_name,good_amount,price
        from good
        where id = #{gid}
    </select>

    <update id="updateGoods">
        update good
        set good_amount = good_amount - #{goodAmount}
        where id=#{id}
    </update>

</mapper>

SaleDao.xml

<?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.xx.dao.SaleDao">

  <insert id="insertSale">
    insert into sale_good(gid,nums) values(#{gid},#{nums})
  </insert>

</mapper>

6、创建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>

    <!-- settings：控制mybatis全局行为 -->
    <!--<settings>
        &lt;!&ndash; 设置mybatis输出日志 &ndash;&gt;
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>-->

    <!-- 定义别名 -->
    <typeAliases>
        <!-- 第一种方式
            指定一个类型为一个自定义别名
            type：自定义类型的全限定名称
            alias：别名
         -->
<!--        <typeAlias type="com.mycompany.domain.User" alias="user" />-->

        <!-- 第二种方式
             <package>
             name：包名，这个包中所有的类，类名就是别名（不区分大小写）
         -->
        <package name="com.mycompany.domain" />
    </typeAliases>


    <!--
        数据源DataSource 放在spring配置文件中
    -->
    <!--<environments default="development">
        <environment id="online">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/onlinedb"/>
                <property name="username" value="root"/>
                <property name="password" value="admin123456"/>
            </dataSource>
        </environment>
    </environments>-->


    <!-- sql mapper（SQL映射文件）的位置 -->
    <mappers>
        <!-- 第一种方式：指定多个mapper文件
            一个mapper标签指定一个文件位置
                从类路径开始（target/classes）
        -->
<!--        <mapper resource="com/mycompany/dao/UserDao.xml" />-->

        <!-- 第二种方式：使用包名
            name：xml（mapper）文件所在的包名，这个包中所有xml文件一次都能加载给mybatis
            使用package要求：
            （1）mapper文件名称需要和接口名称一样（区分大小写）
            （2）mapper文件和dao接口需要在同一目录
        -->
        <package name="com.mycompany.dao" />

    </mappers>

</configuration>

7、创建service接口和实现类，属性是dao

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

8、创建spring的配置文件：声明mybatis对象交给spring创建 （1）数据源DataSource （2）SqlSessionFactory （3）Dao对象 （4）声明自定义的service

jdbc.properties数据库的属性配置文件

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssm
jdbc.user=root
jdbc.password=123456
jdbc.maxActive=20

9、创建测试类

public class TestTransaction {
    @Test
    public void testTransaction(){
        String config = "applicationContext.xml";
        ApplicationContext ac = new ClassPathXmlApplicationContext(config);

        //获取容器中所有对象名
        String names[] = ac.getBeanDefinitionNames();
        for (String name:names){
            System.out.println("容器中对象名称：" + name + "    " + ac.getBean(name));
        }

        //从容器获取service
        BuyGoodService service = (BuyGoodService) ac.getBean("buyGoodService");

        //调用方法
        service.buy(1001,10);
    }
}

在 Spring 中通常可以通过以下两种方式来实现对事务的管理（如上步骤创建项目或者模块，如下两种方式区别之处在下面使用事务过程中会单独区分说明）

一、使用 Spring 的事务注解管理事务

@Transactional注解方案适合中小项目使用

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

使用@Transactional的步骤：

1、需要声明事务管理器对象

<bean id="xx" class="DataSourceTransactionManager">

2、开启事务注解驱动， 告诉spring框架，我要使用注解的方式管理事务

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

spring给业务方法加入事务：

在业务方法执行之前，先开启事务，在业务方法之后提交或回滚事务，使用aop的环绕通知

@Around("要增加的事务功能的业务方法名称")
Object myAround(){
     //spring开启事务
     try{
         buy(1001,10);
         spring的事务管理器.commit();
     }catch(Exception e){
         spring的事务管理器.rollback();
     }
}

通过@Transactional 注解方式，可将事务植入到相应 public 方法中，实现事务管理

@Transactional 的所有可选属性如下

propagation：用于设置事务传播属性。该属性类型为 Propagation 枚举，默认值为

Propagation.REQUIRED。

isolation：用于设置事务的隔离级别。该属性类型为 Isolation 枚举，默认值为

Isolation.DEFAULT

readOnly：用于设置该方法对数据库的操作是否是只读的。该属性为 boolean，默认值

为 false

timeout：用于设置本操作与数据库连接的超时时限。单位为秒，类型为 int，默认值为

-1，即没有时限

rollbackFor：指定需要回滚的异常类。类型为 Class[]，默认值为空数组。当然，若只有

一个异常类时，可以不使用数组

rollbackForClassName：指定需要回滚的异常类类名。类型为 String[]，默认值为空数组。

当然，若只有一个异常类时，可以不使用数组

noRollbackFor：指定不需要回滚的异常类。类型为 Class[]，默认值为空数组。当然，若

只有一个异常类时，可以不使用数组

noRollbackForClassName：指定不需要回滚的异常类类名。类型为 String[]，默认值为空

数组。当然，若只有一个异常类时，可以不使用数组

注：

1、@Transactional 若用在方法上，只能用于 public 方法上。对于其他非public方法，如果加上了注解@Transactional，虽然 Spring 不会报错，但不会将指定事务植入到该方法中。Spring 会忽略掉所有非 public 方法上的@Transaction 注解

2、若@Transaction 注解在类上，则表示该类上所有的方法均将在执行时植入事务

第2步加入依赖

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

        <!-- spring和mybatis集成依赖 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.1</version>
        </dependency>

        <!-- mysql驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.9</version>
        </dependency>

        <!-- 阿里数据库连接池Druid -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.6</version>
        </dependency>

    </dependencies>

第7步创建service类和实现类；主要使用@Transactional注解

public class BuyGoodServiceImpl implements BuyGoodService {

    private SaleDao saleDao;

    private GoodsDao goodsDao;

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

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

    /**
     rollbackFor：表示发生的指定异常一定回滚
     原理：
     （1）spring框架首先会检查方法抛出的异常是不是在rollbackFor的属性值中
     如果异常在rollbackFor列表中，不管什么类型异常，一定回滚
     （2）如果抛出的异常不在rollbackFor列表中，spring会判断异常是不是RuntimeException
     如果是一定回滚
     */
    /*@Transactional(
            propagation = Propagation.REQUIRED,//事务传播行为
            isolation = Isolation.DEFAULT,//事务隔离级别
            readOnly = false,//对数据库的操作是否是只读
            rollbackFor = {//指定需要回滚的异常类。类型为 Class[]，默认值为空数组
                    NullPointerException.class,
                    NotEnoughException.class
            }
    )*/

    /**
     使用事务控制的默认值，默认传播行为是REQUIRED，默认隔离级别是DEFAULT，默认抛出运行时异常回滚事务
     */
    @Transactional
    @Override
    public void buy(Integer goodsId, Integer nums) {
        System.out.println("=====buy方法的开始====");

        //记录销售信息，向sale表添加记录
        Sale sale  = new Sale();
        sale.setGid(goodsId);
        sale.setNums(nums);
        saleDao.insertSale(sale);

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

        System.out.println("=====buy方法的结束====");
    }
}

第8步，创建spring配置文件；主要使用<tx:annotation-driven>

这里要特别注意<tx:annotation-driven>的选择

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

    <!--
        spring加载数据库的属性配置文件
    -->
    <context:property-placeholder location="classpath:jdbc.properties" />

    <!--1、声明数据源DataSource，作用：连接数据库
        将mybatis主配置文件 configuration 下的environments 标签内容移到了这里
        Druid官网：https://github.com/alibaba/druid
        DruidDataSource配置：https://github.com/alibaba/druid/wiki/DruidDataSource%E9%85%8D%E7%BD%AE
     -->
    <bean id="myDataSource" class="com.alibaba.druid.pool.DruidDataSource"
            init-method="init" destroy-method="close">
        <!-- set注入给DruidDataSource提供数据库连接信息 -->
        <!-- 使用属性配置文件中的数据，语法 ${key} -->
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.user}" />
        <property name="password" value="${jdbc.password}" />
        <property name="maxActive" value="${jdbc.maxActive}" />
    </bean>

    <!--2、声明mybatis中提供的SqlSessionFactoryBean类 -->
    <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-config.xml" />
    </bean>

    <!--3、创建dao对象，使用SqlSession的getMapper(xxDao.class)
        MapperScannerConfigurer：内部调用getMapper()方法生成每个dao接口的代理对象
    -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!-- 指定SqlSession对象的id -->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />

        <!-- 指定包名，dao接口所在的包名
            MapperScannerConfigurer会扫描这个包中的所有接口，把每个接口都执行一次getMapper()方法，
            得到每个接口的dao对象
            创建好的dao对象放入到spring容器中；dao对象的默认名称是 接口名首字母小写！！！
        -->
        <property name="basePackage" value="com.mycompany.dao" />
    </bean>

    <!--4、声明service -->
    <bean id="buyGoodService" class="com.mycompany.service.impl.BuyGoodServiceImpl">
        <!-- 通过MapperScannerConfigurer 扫描包；dao对象的默认名称是 接口名首字母小写！！！ -->
        <property name="saleDao" ref="saleDao" />
        <property name="goodsDao" ref="goodsDao" />
    </bean>


    <!-- 使用Spring的事务处理 -->
    <!-- 1、声明事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!-- 连接的数据库，指定数据源 -->
        <property name="dataSource" ref="myDataSource" />
    </bean>

    <!-- 2、开启事务注解驱动（告诉spring使用注解管理事务，创建代理对象）
        transaction-manager:事务管理器对象的id
        tx:annotation-driven 需要选择 http://www.springframework.org/schema/tx
    -->
    <tx:annotation-driven transaction-manager="transactionManager" />

</beans>

二、使用 AspectJ 的 AOP 配置管理事务

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

实现步骤： 都是在xml配置文件中实现

1、使用的是aspectj框架，需要加入依赖

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

2、声明事务管理器对象

<bean id="xx" class="DataSourceTransactionManager">

3、声明方法需要的事务类型（配置方法的事务属性【隔离级别，传播行为，超时】） 

4、配置aop：指定哪些哪类要创建代理

第2步加入依赖；变化：加入了aspectj依赖

<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>
        <!--aspectj依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</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>

        <!-- spring和mybatis集成依赖 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.1</version>
        </dependency>

        <!-- mysql驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.9</version>
        </dependency>

        <!-- 阿里数据库连接池Druid -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.6</version>
        </dependency>

    </dependencies>

第7步创建service类和实现类；没有使用@Transactional注解

public class BuyGoodServiceImpl implements BuyGoodService {

    private SaleDao saleDao;

    private GoodsDao goodsDao;

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

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

    @Override
    public void buy(Integer goodsId, Integer nums) {
        System.out.println("=====buy方法的开始====");

        //记录销售信息，向sale表添加记录
        Sale sale  = new Sale();
        sale.setGid(goodsId);
        sale.setNums(nums);
        saleDao.insertSale(sale);

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

        System.out.println("=====buy方法的结束====");
    }
}

第8步，创建spring配置文件；主要使用<tx:advice>和<aop:config>

这里需要注意选择<tx:advice>

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

    <!--
        spring加载数据库的属性配置文件
    -->
    <context:property-placeholder location="classpath:jdbc.properties" />

    <!--1、声明数据源DataSource，作用：连接数据库
        将mybatis主配置文件 configuration 下的environments 标签内容移到了这里
        Druid官网：https://github.com/alibaba/druid
        DruidDataSource配置：https://github.com/alibaba/druid/wiki/DruidDataSource%E9%85%8D%E7%BD%AE
     -->
    <bean id="myDataSource" class="com.alibaba.druid.pool.DruidDataSource"
            init-method="init" destroy-method="close">
        <!-- set注入给DruidDataSource提供数据库连接信息 -->
        <!-- 使用属性配置文件中的数据，语法 ${key} -->
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.user}" />
        <property name="password" value="${jdbc.password}" />
        <property name="maxActive" value="${jdbc.maxActive}" />
    </bean>

    <!--2、声明mybatis中提供的SqlSessionFactoryBean类 -->
    <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-config.xml" />
    </bean>

    <!--3、创建dao对象，使用SqlSession的getMapper(xxDao.class)
        MapperScannerConfigurer：内部调用getMapper()方法生成每个dao接口的代理对象
    -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!-- 指定SqlSession对象的id -->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />

        <!-- 指定包名，dao接口所在的包名
            MapperScannerConfigurer会扫描这个包中的所有接口，把每个接口都执行一次getMapper()方法，
            得到每个接口的dao对象
            创建好的dao对象放入到spring容器中；dao对象的默认名称是 接口名首字母小写！！！
        -->
        <property name="basePackage" value="com.mycompany.dao" />
    </bean>

    <!--4、声明service -->
    <bean id="buyGoodService" class="com.mycompany.service.impl.BuyGoodServiceImpl">
        <!-- 通过MapperScannerConfigurer 扫描包；dao对象的默认名称是 接口名首字母小写！！！ -->
        <property name="saleDao" ref="saleDao" />
        <property name="goodsDao" ref="goodsDao" />
    </bean>


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

    <!--2、声明业务方法的事务属性（隔离级别，传播行为，超时时间等）
        id：自定义名称；表示 <tx:advice>和</tx:advice>之间的配置内容
        transaction-manager:事务管理器对象的id
        tx:advice 需要选择 http://www.springframework.org/schema/tx
    -->
    <tx:advice id="myAdvice" transaction-manager="treansactionManager">
        <!-- 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.mycompany.exception.NotEnoughException"/>
            <!-- 使用通配符，指定 -->
            <tx:method name="add*" />
        </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="myAdvice" pointcut-ref="servicePt" />
    </aop:config>

</beans>

我们没使用事务，会发现商品库存没有减少，但是新增了销售记录

使用事务机制之后，会发现库存没有减少，但是商品销售记录表的id由12增到了15，是因为中间运行了两次异常，一次为库存不足异常，一次为商品不存在异常

相关文章：

  • 卷妹带你回顾Java基础每日更新Day12
  • UM5006-RT-Thread ART-Pi 数据 flash 擦写手册
  • 【Halcon知识】外轮廓线的算子
  • 能安装Chrome扩展和油猴脚本的手机浏览器
  • 使用Android studio开发一个数独游戏APP 系列第一讲
  • 如何在深度学习中使用自动混合精度训练
  • Linux命令lsscsi详解
  • asp.net webapi 结合Autofac实现程序集动态注入(framework版本)
  • 如何选择合适的进销存管理软件？这几点你需要知道
  • 今日踩坑Maven：omitted for duplicate
  • 时至今日“性能优化”为何依旧成为大厂高工必修
  • 使用谷歌浏览器 devtools 调试node项目
  • 猿创征文 | H5 API之web存储、拖拽事件以及跨文档通信
  • 【数据结构与算法】第六篇：红黑树
  • [Power Query] 分组依据
  • 【翻译】Mashape是如何管理15000个API和微服务的（三）
  • Docker 笔记（2）：Dockerfile
  • Druid 在有赞的实践
  • exif信息对照
  • Java比较器对数组，集合排序
  • JS笔记四：作用域、变量（函数）提升
  • Linux gpio口使用方法
  • linux学习笔记
  • nginx 负载服务器优化
  • puppeteer stop redirect 的正确姿势及 net::ERR_FAILED 的解决
  • SegmentFault 2015 Top Rank
  • spark本地环境的搭建到运行第一个spark程序
  • Terraform入门 - 1. 安装Terraform
  • 精彩代码 vue.js
  • 前端面试之闭包
  • 软件开发学习的5大技巧，你知道吗？
  • 怎么把视频里的音乐提取出来
  • No resource identifier found for attribute,RxJava之zip操作符
  • 1.Ext JS 建立web开发工程
  • Spring第一个helloWorld
  • ​TypeScript都不会用，也敢说会前端？
  • ​人工智能之父图灵诞辰纪念日，一起来看最受读者欢迎的AI技术好书
  • # 飞书APP集成平台-数字化落地
  • （4.10~4.16）
  • （5）STL算法之复制
  • (done) 两个矩阵 “相似” 是什么意思？
  • （Redis使用系列） Springboot 使用Redis+Session实现Session共享 ，简单的单点登录 五
  • （经验分享）作为一名普通本科计算机专业学生，我大学四年到底走了多少弯路
  • (免费领源码）Java#Springboot#mysql农产品销售管理系统47627-计算机毕业设计项目选题推荐
  • （转）关于如何学好游戏3D引擎编程的一些经验
  • .net 7 上传文件踩坑
  • .net core控制台应用程序初识
  • .netcore 如何获取系统中所有session_如何把百度推广中获取的线索（基木鱼，电话，百度商桥等）同步到企业微信或者企业CRM等企业营销系统中...
  • .net连接MySQL的方法
  • [ C++ ] 继承
  • [2023年]-hadoop面试真题(一)
  • [ACM] hdu 1201 18岁生日
  • [acm算法学习] 后缀数组SA
  • [Android] Upload package to device fails #2720
  • [APUE]进程关系(下)