spring---事务处理---学习记录

通过电商购买商品进行事务的异常处理

添加依赖

<?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.node</groupId>
  <artifactId>ch09-spring-trans-anno</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>
    <!--目的是把crc/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>
</project>

创建实体类

Sale.java 购买的商品编号及数量

package com.node.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;
    }
}

Goods.java 库存商品

package com.node.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;
    }
}

创建Dao和mapper文件

SaleDao.java

package com.node.dao;

import com.node.domain.Sale;

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

}

GoodsDao.java

package com.node.dao;

import com.node.domain.Goods;

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

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

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

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.node.dao.GoodsDao">
    <select id="selectGoods" resultType="com.node.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>

创建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>
        <!--name：实体类所在的包名  类名就是别名-->
        <package name="com.node.domain"/>
    </typeAliases>


    <!-- 映射文件，存放sql语句的配置文件 -->
    <mappers>
        <!--name是包名，这个包中的所有mapper.xml一次都能加载-->
        <package name="com.node.dao"/>
    </mappers>
</configuration>

自定义异常类

package com.node.excep;

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

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

}

创建Service接口和实现类 (在实行类中进行事务处理)

BuyGoodsService.java

package com.node.service;

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

BuyGoodsServiceImpl.java

package com.node.service.impl;

import com.node.dao.GoodsDao;
import com.node.dao.SaleDao;
import com.node.domain.Goods;
import com.node.domain.Sale;
import com.node.excep.NotEnoughException;
import com.node.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方法的开始======");
        //记录销售信息，向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.getAmount()<nums){
            //商品库存不足
            throw new NotEnoughException("编号是："+goodsId+",商品库存不足");
        }
        //修改库存
        Goods buyGoods =new Goods();
        buyGoods.setId(goodsId);
        buyGoods.setAmount(nums);
        goodsDao.updateGoods(buyGoods);
        System.out.println("=====buy方法的完成=====");

    }

    public SaleDao getSaleDao() {
        return saleDao;
    }

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

    public GoodsDao getGoodsDao() {
        return goodsDao;
    }

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

配置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: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指定jdbc.properties文件的位置-->
    <context:property-placeholder location="classpath:jdbc.properties" />


    <!--声明数据源DataSource,作用是连接数据库-->
    <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.name}"/>
        <property name="password" value="${jdbc.password}"/>
        <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()生成每个dao接口的代理对象
    -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--指定SqlSessionFactory-->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
        <!--指定包名，包名是dao接口所在的包名
            MapperScannerConfigurer会扫描这个包中的所有接口，把每个接口都执行一次getMapper()方法
            得到每个接口的dao对象。
            创建好的dao对象放入到spring的容器中
        -->
       <property name="basePackage" value="com.node.dao" />
    </bean>

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

</beans>

测试代码

package com.node;

import com.node.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);
        //从容器中获取service
        BuyGoodsService service= (BuyGoodsService) ctx.getBean("buyService");

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

结果

当不出现运行时异常时，程序正常进行，完成数据库操作
当出现运行时异常时，会在BuyGoodsServiceImpl中的buy()方法中进行事务处理，回滚。

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

1.@Transactional注解方案（适合中小项目使用）

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

@Transactional注解时spring框架自己注解，放在public方法的上面，表示当前方法具有事务

使用@Transactional的步骤：
1.需要声明事务管理器对象

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--连接的数据库，指定数据源-->
        <property name="dataSource" ref="myDataSource" />
    </bean>

2.开启事务注解驱动，告诉spring使用注解管理事务
spring使用aop机制，创建@Transactional所在类代理对象，给方法加入事务的功能

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

<!--创建代理对象
          transaction-manager：事务管理器对象的id
    -->
    <tx:annotation-driven transaction-manager="transactionManager" />

在方法上加入

    @Transactional(
            propagation = Propagation.REQUIRED,
            isolation = Isolation.DEFAULT,
            readOnly = false,
            rollbackFor = {
                    NullPointerException.class, NotEnoughException.class
            }
    )

rollbackFor:表示发生指定的异常一定回滚
处理逻辑：
1）spring框架会首先检查方法抛出的异常是不是在rollbackFor的属性中
如果异常在rollbackFor列表中，不管是什么类型的异常，一定回滚
2）如果你抛出的异常不在rollbackFor列表中，spring会判断异常是不是RuntimeException，如果是，则一定回滚

使用的是事务控制的默认值
默认的传播行为是REQUIRED，默认的隔离级别DEFAULT，默认抛出运行时异常，回滚事务

所以一般使用@Transactional即可

2.使用aspextj框架功能（适合大型项目）

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

实现步骤
都是在xml配置文件中实现
1）要使用的是aspectj框架，要加入aspectj依赖

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

2）声明事务管理器对象

<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.node.excep.NotEnoughException"/>

        </tx:attributes>
    </tx:advice>

4）配置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>