• Java--Spring事务

    事务原本是数据库中的概念，在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、创建实体类

    1. public class Goods {
    2.     private Integer id;
    3.     private String goodName;
    4.     private Integer goodAmount;
    5.     private Float price;
    6.  
    7.     public Integer getId() {
    8.         return id;
    9.     }
    10.  
    11.     public void setId(Integer id) {
    12.         this.id = id;
    13.     }
    14.  
    15.     public String getGoodName() {
    16.         return goodName;
    17.     }
    18.  
    19.     public void setGoodName(String goodName) {
    20.         this.goodName = goodName;
    21.     }
    22.  
    23.     public Integer getGoodAmount() {
    24.         return goodAmount;
    25.     }
    26.  
    27.     public void setGoodAmount(Integer goodAmount) {
    28.         this.goodAmount = goodAmount;
    29.     }
    30.  
    31.     public Float getPrice() {
    32.         return price;
    33.     }
    34.  
    35.     public void setPrice(Float price) {
    36.         this.price = price;
    37.     }
    38. }
    39.  
    40.  
    41. public class Sale {
    42.     private Integer id;
    43.     private Integer gid;
    44.     private Integer nums;
    45.  
    46.     public Integer getId() {
    47.         return id;
    48.     }
    49.  
    50.     public void setId(Integer id) {
    51.         this.id = id;
    52.     }
    53.  
    54.     public Integer getGid() {
    55.         return gid;
    56.     }
    57.  
    58.     public void setGid(Integer gid) {
    59.         this.gid = gid;
    60.     }
    61.  
    62.     public Integer getNums() {
    63.         return nums;
    64.     }
    65.  
    66.     public void setNums(Integer nums) {
    67.         this.nums = nums;
    68.     }
    69. }

    5、创建dao接口和mapper文件

    1. public interface GoodsDao {
    2.     //更新库存
    3.     //goods表示本次用户购买的商品信息， id， 购买数量
    4.     int updateGoods(Goods goods);
    5.  
    6.     //查询商品的信息
    7.     Goods selectGoods(Integer id);
    8. }
    9.  
    10.  
    11. public interface SaleDao {
    12.     //增加销售记录
    13.     int insertSale(Sale sale);
    14. }

     GoodsDao.xml

    1. "1.0" encoding="UTF-8" ?>
    2. mapper
    3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
    4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    5. <mapper namespace="com.xx.dao.GoodsDao">
    6.  
    7.     <resultMap id="goodMap" type="com.xx.domain.Goods">
    8.         <id column="id" property="id" />
    9.         <result column="good_name" property="goodName" />
    10.         <result column="good_amount" property="goodAmount" />
    11.         <result column="price" property="price" />
    12.     resultMap>
    13.  
    14.     <select id="selectGoods" resultMap="goodMap">
    15.         select id,good_name,good_amount,price
    16.         from good
    17.         where id = #{gid}
    18.     select>
    19.  
    20.     <update id="updateGoods">
    21.         update good
    22.         set good_amount = good_amount - #{goodAmount}
    23.         where id=#{id}
    24.     update>
    25.  
    26. mapper>

    SaleDao.xml

    1. "1.0" encoding="UTF-8" ?>
    2. mapper
    3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
    4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    5. <mapper namespace="com.xx.dao.SaleDao">
    6.  
    7.   <insert id="insertSale">
    8.     insert into sale_good(gid,nums) values(#{gid},#{nums})
    9.   insert>
    10.  
    11. mapper>

    6、创建mybatis主配置文件

    1. "1.0" encoding="UTF-8" ?>
    2. configuration
    3.         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
    4.         "http://mybatis.org/dtd/mybatis-3-config.dtd">
    5. <configuration>
    6.  
    7.     
    8.     
    9.  
    10.     
    11.     <typeAliases>
    12.         
    14.  
    15.         
    16.         <package name="com.mycompany.domain" />
    17.     typeAliases>
    18.  
    19.  
    20.     
    21.     
    22.  
    23.  
    24.     
    25.     <mappers>
    26.         
    28.  
    29.         
    30.         <package name="com.mycompany.dao" />
    31.  
    32.     mappers>
    33.  
    34. configuration>

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

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

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

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

    1. jdbc.driver=com.mysql.jdbc.Driver
    2. jdbc.url=jdbc:mysql://localhost:3306/ssm
    3. jdbc.user=root
    4. jdbc.password=123456
    5. jdbc.maxActive=20

    9、创建测试类

    1. public class TestTransaction {
    2.     @Test
    3.     public void testTransaction(){
    4.         String config = "applicationContext.xml";
    5.         ApplicationContext ac = new ClassPathXmlApplicationContext(config);
    6.  
    7.         //获取容器中所有对象名
    8.         String names[] = ac.getBeanDefinitionNames();
    9.         for (String name:names){
    10.             System.out.println("容器中对象名称：" + name + "    " + ac.getBean(name));
    11.         }
    12.  
    13.         //从容器获取service
    14.         BuyGoodService service = (BuyGoodService) ac.getBean("buyGoodService");
    15.  
    16.         //调用方法
    17.         service.buy(1001,10);
    18.     }
    19. }

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

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

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

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

    使用@Transactional的步骤：

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

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

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

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

    spring给业务方法加入事务：

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

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

    通过@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步加入依赖

    1. <dependencies>
    2.  
    3.         
    4.         <dependency>
    5.             <groupId>junitgroupId>
    6.             <artifactId>junitartifactId>
    7.             <version>4.11version>
    8.             <scope>testscope>
    9.         dependency>
    10.  
    11.         
    12.         <dependency>
    13.             <groupId>org.springframeworkgroupId>
    14.             <artifactId>spring-contextartifactId>
    15.             <version>5.2.5.RELEASEversion>
    16.         dependency>
    17.         
    18.         <dependency>
    19.             <groupId>org.springframeworkgroupId>
    20.             <artifactId>spring-txartifactId>
    21.             <version>5.2.5.RELEASEversion>
    22.         dependency>
    23.         <dependency>
    24.             <groupId>org.springframeworkgroupId>
    25.             <artifactId>spring-jdbcartifactId>
    26.             <version>5.2.5.RELEASEversion>
    27.         dependency>
    28.  
    29.         
    30.         <dependency>
    31.             <groupId>org.mybatisgroupId>
    32.             <artifactId>mybatisartifactId>
    33.             <version>3.5.1version>
    34.         dependency>
    35.  
    36.         
    37.         <dependency>
    38.             <groupId>org.mybatisgroupId>
    39.             <artifactId>mybatis-springartifactId>
    40.             <version>2.0.1version>
    41.         dependency>
    42.  
    43.         
    44.         <dependency>
    45.             <groupId>mysqlgroupId>
    46.             <artifactId>mysql-connector-javaartifactId>
    47.             <version>5.1.9version>
    48.         dependency>
    49.  
    50.         
    51.         <dependency>
    52.             <groupId>com.alibabagroupId>
    53.             <artifactId>druidartifactId>
    54.             <version>1.2.6version>
    55.         dependency>
    56.  
    57.     dependencies>

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

    1. public class BuyGoodServiceImpl implements BuyGoodService {
    2.  
    3.     private SaleDao saleDao;
    4.  
    5.     private GoodsDao goodsDao;
    6.  
    7.     public void setSaleDao(SaleDao saleDao) {
    8.         this.saleDao = saleDao;
    9.     }
    10.  
    11.     public void setGoodsDao(GoodsDao goodsDao) {
    12.         this.goodsDao = goodsDao;
    13.     }
    14.  
    15.     /**
    16.      rollbackFor：表示发生的指定异常一定回滚
    17.      原理：
    18.      （1）spring框架首先会检查方法抛出的异常是不是在rollbackFor的属性值中
    19.      如果异常在rollbackFor列表中，不管什么类型异常，一定回滚
    20.      （2）如果抛出的异常不在rollbackFor列表中，spring会判断异常是不是RuntimeException
    21.      如果是一定回滚
    22.      */
    23.     /*@Transactional(
    24.             propagation = Propagation.REQUIRED,//事务传播行为
    25.             isolation = Isolation.DEFAULT,//事务隔离级别
    26.             readOnly = false,//对数据库的操作是否是只读
    27.             rollbackFor = {//指定需要回滚的异常类。类型为 Class[]，默认值为空数组
    28.                     NullPointerException.class,
    29.                     NotEnoughException.class
    30.             }
    31.     )*/
    32.  
    33.     /**
    34.      使用事务控制的默认值，默认传播行为是REQUIRED，默认隔离级别是DEFAULT，默认抛出运行时异常回滚事务
    35.      */
    36.     @Transactional
    37.     @Override
    38.     public void buy(Integer goodsId, Integer nums) {
    39.         System.out.println("=====buy方法的开始====");
    40.  
    41.         //记录销售信息，向sale表添加记录
    42.         Sale sale  = new Sale();
    43.         sale.setGid(goodsId);
    44.         sale.setNums(nums);
    45.         saleDao.insertSale(sale);
    46.  
    47.         //更新库存
    48.         Goods goods  = goodsDao.selectGoods(goodsId);
    49.         if( goods == null){
    50.             //商品不存在
    51.             throw new NullPointerException("编号是："+goodsId+",商品不存在");
    52.         } else if(goods.getGoodAmount() < nums){
    53.             //商品库存不足
    54.             throw new NotEnoughException("编号是："+goodsId+",商品库存不足");
    55.         }
    56.         //修改库存了
    57.         Goods buyGoods = new Goods();
    58.         buyGoods.setId( goodsId);
    59.         buyGoods.setGoodAmount(nums);
    60.         goodsDao.updateGoods(buyGoods);
    61.  
    62.         System.out.println("=====buy方法的结束====");
    63.     }
    64. }

    第8步，创建spring配置文件；主要使用

    这里要特别注意的选择

    1. "1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
    5.        xsi:schemaLocation="http://www.springframework.org/schema/beans
    6.        http://www.springframework.org/schema/beans/spring-beans.xsd
    7.        http://www.springframework.org/schema/context
    8.        https://www.springframework.org/schema/context/spring-context.xsd
    9.        http://www.springframework.org/schema/tx
    10.        http://www.springframework.org/schema/tx/spring-tx.xsd">
    11.  
    12.     
    13.     <context:property-placeholder location="classpath:jdbc.properties" />
    14.  
    15.     
    16.     <bean id="myDataSource" class="com.alibaba.druid.pool.DruidDataSource"
    17.             init-method="init" destroy-method="close">
    18.         
    19.         
    20.         <property name="url" value="${jdbc.url}" />
    21.         <property name="username" value="${jdbc.user}" />
    22.         <property name="password" value="${jdbc.password}" />
    23.         <property name="maxActive" value="${jdbc.maxActive}" />
    24.     bean>
    25.  
    26.     
    27.     <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean" >
    28.         
    29.         <property name="dataSource" ref="myDataSource" />
    30.  
    31.         
    32.         <property name="configLocation" value="classpath:mybatis-config.xml" />
    33.     bean>
    34.  
    35.     
    36.     <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    37.         
    38.         <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
    39.  
    40.         
    41.         <property name="basePackage" value="com.mycompany.dao" />
    42.     bean>
    43.  
    44.     
    45.     <bean id="buyGoodService" class="com.mycompany.service.impl.BuyGoodServiceImpl">
    46.         
    47.         <property name="saleDao" ref="saleDao" />
    48.         <property name="goodsDao" ref="goodsDao" />
    49.     bean>
    50.  
    51.  
    52.     
    53.     
    54.     <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    55.         
    56.         <property name="dataSource" ref="myDataSource" />
    57.     bean>
    58.  
    59.     
    60.     <tx:annotation-driven transaction-manager="transactionManager" />
    61.  
    62. beans>

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

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

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

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

    1.     <dependency>
    2.         <groupId>org.springframeworkgroupId>
    3.         <artifactId>spring-aspectsartifactId>
    4.         <version>5.2.5.RELEASEversion>
    5.     dependency>

    2、声明事务管理器对象

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

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

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

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

    1. <dependencies>
    2.  
    3.         
    4.         <dependency>
    5.             <groupId>junitgroupId>
    6.             <artifactId>junitartifactId>
    7.             <version>4.11version>
    8.             <scope>testscope>
    9.         dependency>
    10.  
    11.         
    12.         <dependency>
    13.             <groupId>org.springframeworkgroupId>
    14.             <artifactId>spring-contextartifactId>
    15.             <version>5.2.5.RELEASEversion>
    16.         dependency>
    17.         
    18.         <dependency>
    19.             <groupId>org.springframeworkgroupId>
    20.             <artifactId>spring-aspectsartifactId>
    21.             <version>5.2.5.RELEASEversion>
    22.         dependency>
    23.         
    24.         <dependency>
    25.             <groupId>org.springframeworkgroupId>
    26.             <artifactId>spring-txartifactId>
    27.             <version>5.2.5.RELEASEversion>
    28.         dependency>
    29.         <dependency>
    30.             <groupId>org.springframeworkgroupId>
    31.             <artifactId>spring-jdbcartifactId>
    32.             <version>5.2.5.RELEASEversion>
    33.         dependency>
    34.  
    35.         
    36.         <dependency>
    37.             <groupId>org.mybatisgroupId>
    38.             <artifactId>mybatisartifactId>
    39.             <version>3.5.1version>
    40.         dependency>
    41.  
    42.         
    43.         <dependency>
    44.             <groupId>org.mybatisgroupId>
    45.             <artifactId>mybatis-springartifactId>
    46.             <version>2.0.1version>
    47.         dependency>
    48.  
    49.         
    50.         <dependency>
    51.             <groupId>mysqlgroupId>
    52.             <artifactId>mysql-connector-javaartifactId>
    53.             <version>5.1.9version>
    54.         dependency>
    55.  
    56.         
    57.         <dependency>
    58.             <groupId>com.alibabagroupId>
    59.             <artifactId>druidartifactId>
    60.             <version>1.2.6version>
    61.         dependency>
    62.  
    63.     dependencies>

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

    1. public class BuyGoodServiceImpl implements BuyGoodService {
    2.  
    3.     private SaleDao saleDao;
    4.  
    5.     private GoodsDao goodsDao;
    6.  
    7.     public void setSaleDao(SaleDao saleDao) {
    8.         this.saleDao = saleDao;
    9.     }
    10.  
    11.     public void setGoodsDao(GoodsDao goodsDao) {
    12.         this.goodsDao = goodsDao;
    13.     }
    14.  
    15.     @Override
    16.     public void buy(Integer goodsId, Integer nums) {
    17.         System.out.println("=====buy方法的开始====");
    18.  
    19.         //记录销售信息，向sale表添加记录
    20.         Sale sale  = new Sale();
    21.         sale.setGid(goodsId);
    22.         sale.setNums(nums);
    23.         saleDao.insertSale(sale);
    24.  
    25.         //更新库存
    26.         Goods goods  = goodsDao.selectGoods(goodsId);
    27.         if( goods == null){
    28.             //商品不存在
    29.             throw new NullPointerException("编号是："+goodsId+",商品不存在");
    30.         } else if(goods.getGoodAmount() < nums){
    31.             //商品库存不足
    32.             throw new NotEnoughException("编号是："+goodsId+",商品库存不足");
    33.         }
    34.         //修改库存了
    35.         Goods buyGoods = new Goods();
    36.         buyGoods.setId( goodsId);
    37.         buyGoods.setGoodAmount(nums);
    38.         goodsDao.updateGoods(buyGoods);
    39.  
    40.         System.out.println("=====buy方法的结束====");
    41.     }
    42. }

    第8步，创建spring配置文件；主要使用和

    这里需要注意选择

    1. "1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xmlns:context="http://www.springframework.org/schema/context"
    5.        xmlns:tx="http://www.springframework.org/schema/tx" xmlns:util="http://www.springframework.org/schema/util"
    6.        xmlns:aop="http://www.springframework.org/schema/aop"
    7.        xsi:schemaLocation="http://www.springframework.org/schema/beans
    8.        http://www.springframework.org/schema/beans/spring-beans.xsd
    9.        http://www.springframework.org/schema/context
    10.        https://www.springframework.org/schema/context/spring-context.xsd
    11.        http://www.springframework.org/schema/tx
    12.        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">
    13.  
    14.     
    15.     <context:property-placeholder location="classpath:jdbc.properties" />
    16.  
    17.     
    18.     <bean id="myDataSource" class="com.alibaba.druid.pool.DruidDataSource"
    19.             init-method="init" destroy-method="close">
    20.         
    21.         
    22.         <property name="url" value="${jdbc.url}" />
    23.         <property name="username" value="${jdbc.user}" />
    24.         <property name="password" value="${jdbc.password}" />
    25.         <property name="maxActive" value="${jdbc.maxActive}" />
    26.     bean>
    27.  
    28.     
    29.     <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean" >
    30.         
    31.         <property name="dataSource" ref="myDataSource" />
    32.  
    33.         
    34.         <property name="configLocation" value="classpath:mybatis-config.xml" />
    35.     bean>
    36.  
    37.     
    38.     <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    39.         
    40.         <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
    41.  
    42.         
    43.         <property name="basePackage" value="com.mycompany.dao" />
    44.     bean>
    45.  
    46.     
    47.     <bean id="buyGoodService" class="com.mycompany.service.impl.BuyGoodServiceImpl">
    48.         
    49.         <property name="saleDao" ref="saleDao" />
    50.         <property name="goodsDao" ref="goodsDao" />
    51.     bean>
    52.  
    53.  
    54.     
    55.     
    56.     <bean id="treansactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    57.         
    58.         <property name="dataSource" ref="myDataSource" />
    59.     bean>
    60.  
    61.     
    62.     <tx:advice id="myAdvice" transaction-manager="treansactionManager">
    63.         
    64.         <tx:attributes>
    65.             
    66.             <tx:method name="buy" propagation="REQUIRED" isolation="DEFAULT"
    67.                 rollback-for="java.lang.NullPointerException,com.mycompany.exception.NotEnoughException"/>
    68.             
    69.             <tx:method name="add*" />
    70.         tx:attributes>
    71.     tx:advice>
    72.  
    73.     
    74.     <aop:config>
    75.         
    76.         <aop:pointcut id="servicePt" expression="execution(* *..service..*.*(..))"/>
    77.  
    78.         
    79.         <aop:advisor advice-ref="myAdvice" pointcut-ref="servicePt" />
    80.     aop:config>
    81.  
    82. beans>

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

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

  • 相关阅读:
    AI 驱动的医疗变革：迈向未来医疗新生态
    怎么彻底粉碎文件夹？文件还能恢复吗？操作过程在这里
    python-----matplotlib详细教程（未完...）
    2023最新SSM计算机毕业设计选题大全（附源码+LW）之java家猪智能饲养管理系统wt2ah
    python使用websocket实现多端数据同步，多个websocket同步消息，断开链接自动清理
    Tessent scan & ATPG(8) Debug low test coverage(低测试覆盖率的原因及debug方法)
    【无标题】
    国产 Web 组态软件 TopStack V5.0 发布
    【MCAL_CANDriver】-2.1-硬件过滤(Hardware Filter)详述及配置
    你不会还以为“&&”前后判断条件可以随便放吧？哭死
  • 原文地址：https://blog.csdn.net/MinggeQingchun/article/details/123155518