spring-事务案例

原创于 2021-10-14 16:53:10 发布 · 902 阅读

6 ·

CC 4.0 BY-SA版权

文章标签：

#spring #java

Spring 专栏收录该内容

11 篇文章

订阅专栏

本文详细介绍了Spring事务管理的三种方式：1) 使用Spring事务管理API，包括创建数据库表、配置文件等内容；2) 通过Spring的@Transactional注解管理事务，适合中小项目，介绍注解属性及使用步骤；3) 利用Aspectj的AOP配置管理事务，适用于大型项目，强调事务配置与业务方法的分离。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

spring-事务案例

1.spring事务管理API
2.使用spring的事务注解管理事务
3.使用Aspectj的AOP配置管理事务

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

1.spring事务管理API

1.创建数据库表
创建两个数据库表sale，goods
sale 销售表

goods 商品表
在这里插入图片描述

goods表数据
在这里插入图片描述

2.maven依赖 pom.xml

<?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.putao</groupId>
  <artifactId>ch08-spring-trans</artifactId>
  <version>1.0-SNAPSHOT</version>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>

  <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.8.1</version>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
        </configuration>
      </plugin>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <configuration>
          <source>6</source>
          <target>6</target>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

3.创建实体类

package com.putao.domain;

public class Goods {

    private Integer id;
    private String name;
    private Integer amount;
    private Float 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;
    }
}

package com.putao.domain;

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

4.定义dao接口

package com.putao.dao;

import com.putao.domain.Goods;

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

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

package com.putao.dao;

import com.putao.domain.Sale;

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

5.定义dao接口对应的sql映射文件

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

    <select id="selectGoods" resultType="com.putao.domain.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>

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

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

6.定义异常类

package com.putao.excep;

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

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

7.定义Service接口

package com.putao.service;

public interface BuyGoodsService {

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

8.定义Service的实现类

package com.putao.service.impl;

import com.putao.dao.GoodsDao;
import com.putao.dao.SaleDao;
import com.putao.domain.Goods;
import com.putao.domain.Sale;
import com.putao.excep.NotEnoughException;
import com.putao.service.BuyGoodsService;

public class BuyGoodsServiceImpl implements BuyGoodsService {

    private SaleDao saleDao;
    private GoodsDao goodsDao;

    @Override
    public void buy(Integer goodsId, Integer nums) {
        System.out.println("====buy方法的开始====");
        //1.记录销售信息，向sale表添加记录
        Sale sale = new Sale();
        sale.setGid(goodsId);
        sale.setNums(nums);
        saleDao.insertSale(sale);
        //2.更新库存
        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;
    }

}

9.修改Spring配置文件内容
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>

<!--    设置别名-->
    <typeAliases>
<!--        name:实体类所在的包名-->
        <package name="com.putao.domain"/>
    </typeAliases>
    <!-- sql mapper（sql映射文件的位置）-->
    <mappers>
    <!--
        name:是包名，这个包中的所有mapper.xml一次都能加载
    -->
        <package name="com.putao.dao"/>
    </mappers>
</configuration>

jdbc.properties

jdbc.url=jdbc:mysql://localhost:3306/springdb?characterEncoding=utf-8
jdbc.username=root
jdbc.passwd=root
jdbc.max=30

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

<!--    把数据库的配置信息，写在一个独立的文件，便于修改数据库的配置内容
        spring知道jdbc.properties文件的位置
-->
    <context:property-placeholder location="classpath:jdbc.properties"/>
<!--    声明数据源DayaSource,作用是连接数据库的-->
    <bean id="myDataSource" class="com.alibaba.druid.pool.DruidDataSource"
          init-method="init" destroy-method="close" >
<!--        set注入给DruidDataSource提供连接数据库信息-->
<!--        使用属性配置文件中的数据，语法${key}-->
        <property name="url" value="${jdbc.url}"/> <!--setUrl()-->
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.passwd}" />
        <property name="maxActive" value="${jdbc.max}" />
    </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)
        MapperScannerConfigurer：在内部调用getMapper()生成每个到接口的代理对象
     -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<!--        指定SqlSessionFactory对象的id-->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
    <!--指定包名，包名是dao接口所在的包名
        MapperScannerConfigurer会扫描这个包中的所有接口，把每个接口都执行
        一次getMapper()方法，得到每个接口的dao对象。
        创建好的dao对象放入到spring的容器中的。dao对象的默认名称是 接口名首字母小写
    -->
        <property name="basePackage" value="com.putao.dao" />
    </bean>

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

10.定义测试类

package com.putao;

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

public class MyTest {

    @Test
    public void test01(){
        String config="applicationContext.xml";
        ApplicationContext ctx = new ClassPathXmlApplicationContext(config);
        //从容器中获取数据
        BuyGoodsService service = (BuyGoodsService) ctx.getBean("buyService");

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

2.使用spring的事务注解管理事务

适合中小项目使用的，注解方案。
spring框架自己用aop实现给业务方法增加事务的功能，使用@Transactional注解增加事务。
@Transactional注解是spring框架自己注解，放在public方法的上面，表示当前方法具有事务。
可以给注解属性赋值，表示具体的隔离级别，传播行为，异常信息等等。

@Transactional的所有可选属性如下所示：

name 当在配置文件中有多个 TransactionManager , 可以用该属性指定选择哪个事务管理器。
propagation 事务的传播行为，默认值为 REQUIRED。
isolation 事务的隔离度，默认值采用 DEFAULT。
timeout 事务的超时时间，默认值为-1。如果超过该时间限制但事务还没有完成，则自动回滚事务。
read-only 指定事务是否为只读事务，默认值为 false；为了忽略那些不需要事务的方法，比如读取数据，可以设置 read-only 为 true。
rollback-for 用于指定能够触发事务回滚的异常类型，如果有多个异常类型需要指定，各类型之间可以通过逗号分隔。
no-rollback- for 抛出 no-rollback-for 指定的异常类型，不回滚事务。

=====================================================================
使用@Transactional的步骤

1.需要声明事务管理器对象
<bean id="xx" class="DataSourceTransactionManager">

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

2.开启事务注解驱动，告诉spring框架，我要使用注解的方式管理事务.
spring使用aop机制，创建@Transactional所在的类代理对象，给方法加入事务的功能。
spring给业务方法加入事务：
在你的业务方法执行之前，先开启事务，在业务方法之后提交或回滚事务，使用aop的环绕通知。

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

<!--    2.开启事务注解驱动，告诉spring使用注解管理事务，创建代理对象
        transaction-manager：事务管理器对象的id-->
    <tx:annotation-driven transaction-manager="transactionManager" />

3.在你的方法的上面加入@Transactional

/**
     *
     * rollbackFor: 表示发生指定的异常一定回滚
     * 处理逻辑是：
     *      1）spring框架会首先检查方法抛出的异常是不是在rollbackFor的属性值中
     *          如果异常在rollbackFor列表中，不管是什么类型的异常，一定回滚。
     *      2）如果你抛出的异常不在rollbackFor列表中，spring会判断异常是不是RuntimeException,
     *      如果是一定回滚。
     */
//    @Transactional(
//            propagation = Propagation.REQUIRED,
//            isolation = Isolation.DEFAULT,
//            readOnly = false,
//            rollbackFor = {
//                    NullPointerException.class,
//                    NotEnoughException.class
//            }
//    )
    //使用的是事务控制的默认值，默认的传播行为是REQUIRED，默认的隔离级别是DEFAULT
    //默认抛出运行时异常，回滚事务
    @Transactional
    @Override
    public void buy(Integer goodsId, Integer nums) {
        System.out.println("====buy方法的开始====");
        //1.记录销售信息，向sale表添加记录
        Sale sale = new Sale();
        sale.setGid(goodsId);
        sale.setNums(nums);
        saleDao.insertSale(sale);
        //2.更新库存
        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方法的完成====");
    }

3.使用Aspectj的AOP配置管理事务

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

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

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

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

2.声明事务管理器对象

<!--    声明式事物处理：和源代码完全分离的-->
<!--    1.声明事务管理器对象-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="myDataSource"/>
    </bean>

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

<!--    2.声明业务方法它的业务属性（隔离级别，传播行为，超时时间）
           id:自定义名称，表示<tx:advice>和</tx:advice>之间配置内容的
           transaction-manager:事务管理器对象的id
-->
    <tx:advice id="myAdvice" transaction-manager="transactionManager" >
<!--        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.putao.excep.NotEnoughException"/>
<!--            使用通配符，指定很多的方法-->
            <tx:method name="add*" propagation="REQUIRES_NEW" />
<!--            指定修改方法-->
            <tx:method name="modify*" />
<!--            删除方法-->
            <tx:method name="remove*" />
<!--            查询方法,query,search,find-->
            <tx:method name="*" propagation="SUPPORTS" read-only="true" />
        </tx:attributes>
    </tx:advice>

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

<!--    配置aop-->
    <aop:config>
<!--        配置切入点表达式：指定哪些包中要使用事务
            id:切入点表达式的名称，唯一值
            expression：切入点表达式,指定哪些类要使用事务，aspectj会创建代理对象

            com.putao.service
            com.crm.service
            com.service
-->
        <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>