Spring框架-----＞(6) 详谈Spring事务

一、Spring事务

概念：
事务原本是数据库中的概念，是指一组sql语句的集合，集合中有多条sql语句可能是insert ， update ，select ，delete， 我们希望这些多个sql语句都能成功，或者都失败， 这些sql语句的执行是一致的，作为一个整体执行。但一般情况下，需要将事务提升到业务层，即Service层。这样做是为了能够使用事务的特性来管理具体的业务。

1、多种数据库处理事务的方式

• jdbc访问数据库，处理事务 Connection conn ; conn.commit(); conn.rollback();
• mybatis访问数据库，处理事务， SqlSession.commit(); SqlSession.rollback();
• hibernate访问数据库，处理事务， Session.commit(); Session.rollback();

存在不足：
1）不同的数据库访问技术，其对应的处理事务的对象和方法不同，需要了解不同数据库访问技术使用事务的原理
2）掌握多种数据库中事务的处理逻辑，即什么时候提价事务，什么时候回滚事务

2、在Spring中通常可以通过以下两种方式来实现对事务的管理

• 1）使用Spring的事务注解管理事务
• 2）使用AspectJ的AOP配置管理事务

3、事务管理器

概念：
事务管理器是PlatformTransactionManager 接口对象。其主要用于完成事务的提交、回 滚，及获取事务的状态信息。

• 1）接口：PlatformTransactionManager ，定义了事务重要的方法commit，rollback
• 2）实现类：spring把每一种数据库访问技术对应的事务处理类都创建好了

➢ DataSourceTransactionManager：使用 JDBC 或 MyBatis 进行数据库操作时使用。
➢ HibernateTransactionManager：使用 Hibernate 进行持久化数据时使用

4、如何使用事务管理器

声明数据库访问技术对于的事务管理器实现类， 在spring的配置文件中使用< bean >声明就可以了
例如，你要使用mybatis访问数据库，你应该在xml配置文件中
<bean id=“xxx" class="…DataSourceTransactionManager">

5、声明处理事务的类型

（1）事务的隔离级别

➢DEFAULT：采用 DB 默认的事务隔离级别。MySql 的默认为 REPEATABLE_READ； Oracle默认为 READ_COMMITTED。
➢READ_UNCOMMITTED：读未提交。未解决任何并发问题。
➢READ_COMMITTED：读已提交。解决脏读，存在不可重复读与幻读。
➢REPEATABLE_READ：可重复读。解决脏读、不可重复读，存在幻读
➢SERIALIZABLE：串行化。不存在并发问题。

（2）事务的传播行为

概念：
表示你的业务方法调用时，事务在方法之间是如何使用的。
例如：A 事务中的方法 doSome()调用 B 事务中的方法 doOther()，在调用执行期间事务的维护情况，就称为事务传播行为。事务传播行为是加在方法上的。

• PROPAGATION_REQUIRED

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

• PROPAGATION_REQUIRES_NEW

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

• PROPAGATION_SUPPORTS

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

• PROPAGATION_MANDATORY
• PROPAGATION_NESTED
• PROPAGATION_NEVER
• PROPAGATION_NOT_SUPPORTED

（3）事务超时时限

表示一个方法最长的执行时间，如果方法执行时超过了时间，事务就回滚。一般使用默认值即可。

6、事务提交后回滚事务的时机

1）当你的业务方法，执行成功，没有异常抛出，当方法执行完毕，spring在方法执行后提交事务。事务管理器commit

2）当你的业务方法抛出运行时异常或ERROR， spring执行回滚，调用事务管理器的rollback
运行时异常的定义： RuntimeException 和他的子类都是运行时异常，即只有在运行时才出现的异常。例如NullPointException , NumberFormatException

3）当你的业务方法抛出非运行时异常， 主要是受查异常时，提交事务
受查异常：也叫编译时异常，即在代码编写时要求必须捕获或抛出的异常，若不处理，
则无法通过编译。例如IOException, SQLException

7、总结Spring事务

（1）指定要使用的事务管理器实现类，使用< bean >

（2）指定哪些类、哪些方法需要加入事务的功能

（3）指定方法需要的隔离级别、传播行为、超时时限

程序员要做的是将项目中类信息，方法名称、方法事务的传播行为等告诉Spring容器

8、程序举例

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

（1）在maven中加入依赖

<dependencies>
  <!--单元测试-->
  <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.11</version>
    <scope>test</scope>
  </dependency>

  <!--spring依赖-->
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.2.3.RELEASE</version>
  </dependency>

  <!--做spring事务依赖-->
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
    <version>5.2.3.RELEASE</version>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.3.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.48</version>
  </dependency>

  <!--连接池-->
  <dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.2.1</version>
  </dependency>

</dependencies>

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

（2）创建实体类Sale和Goods

public class Sale {
    
    
    private Integer id;
    private Integer gid;
    private Integer nums;
//这里省略set方法

public class Goods {
    
    
    private Integer id;
    private String name;
    private Integer amount;
    private Float price;

（3）定义实体类dao接口

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

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

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

（4）定义dao接口对应的sql映射文件

<mapper namespace="com.hcz.dao.SaleDao">
    <insert id="insertSale" >
        insert into sale(gid,nums) values (#{gid},#{nums})
    </insert>
</mapper>

<mapper namespace="com.hcz.dao.GoodsDao">
    <select id="selectGoods" resultType="com.hcz.entity.Goods">
          select * from goods where id=#{gid}
    </select>

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

（5）创建自定义异常类

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

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

（6）定义Service接口

public interface BuyGoodsService {
    
    
    void buy(Integer goodsid,Integer nums);
}

（7）定义Service接口的实现类

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+",商品库存不足");
        }

        //3、修改库存信息
        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;
    }
}

（8）修改Spring配置文件内容

A、声明mybatis对象

<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提供连接数据库信息 -->
    <!--    使用属性配置文件中的数据，语法 ${key} -->
    <property name="url" value="${jdbc.url}" /><!--setUrl()-->
    <property name="username" value="${jdbc.username}"/>
    <property name="password" value="${jdbc.password}" />
    <property name="maxActive" value="20" />
</bean>

<!--注册 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接口的代理对象。

-->
<!--声明Mybatis的扫描器对象，创建Dao接口的实现类对象，即Dao对象-->
<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.hcz.dao"/>
</bean>

B、声明业务层对象

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

（9）定义测试类

@Test
public void test01(){
    
    
    String config = "applicationContext.xml";
    ApplicationContext ctx = new ClassPathXmlApplicationContext(config);

    //从容器中获取service
    BuyGoodsService buyGoodsService = (BuyGoodsService) ctx.getBean("buyGoodsService");

    //调用方法
    buyGoodsService.buy(1001,5);
}

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

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

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

• propagation：用于设置事务传播属性。该属性类型为 Propagation 枚举，默认值为Propagation.REQUIRED
• isolation：用于设置事务的隔离级别。该属性类型为 Isolation 枚举，默认值为 Isolation.DEFAULT
• readOnly：用于设置该方法对数据库的操作是否是只读的。该属性为 boolean，默认值 为 false
• timeout：用于设置本操作与数据库连接的超时时限。单位为秒，类型为 int，默认值为 -1，即没有时限
• rollbackFor：指定需要回滚的异常类。类型为 Class[ ]，默认值为空数组。当然，若只有 一个异常类时，可以不使用数组
• rollbackForClassName：指定需要回滚的异常类类名。类型为 String[ ]，默认值为空数组。 当然，若只有一个异常类时，可以不使用数组
• noRollbackFor：指定不需要回滚的异常类。类型为 Class[ ]，默认值为空数组。当然，若只有一个异常类时，可以不使用数组
• noRollbackForClassName：指定不需要回滚的异常类类名。类型为 String[ ]，默认值为空数组。当然，若只有一个异常类时，可以不使用数组

注意：
@Transactional 若用在方法上，只能用于 public 方法上。对于其他非 public 方法，如果加上了注解@Transactional，虽然 Spring 不会报错，但不会将指定事务织入到该 方法中。因为 Spring 会忽略掉所有非 public 方法上的@Transaction 注解。 若@Transaction 注解在类上，则表示该类上所有的方法均将在执行时织入事务。

使用@Transactional的步骤：

1）声明事务管理器

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

2）开启事务注解驱动

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

spring使用aop机制，创建@Transactional所在的类代理对象，给方法加入事务的功能
spring给业务方法加入事务：
在你的业务方法执行之前，先开启事务，在业务方法之后提交或回滚事务，使用aop的环绕通知

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

3）业务层public方法的上面加入事务属性

@Transactional(
        propagation = Propagation.REQUIRED,
        isolation = Isolation.DEFAULT,
        readOnly = false,
        rollbackFor = {
    
    
               NullPointerException.class,NotEnoughException.class
        }
)
@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+",商品库存不足");
    }

    //3、修改库存信息
    Goods buyGoods = new Goods();
    buyGoods.setId(goodsid);
    buyGoods.setAmount(nums);
    goodsDao.updateGoods(buyGoods);
    System.out.println("===========buy方法的结束===========");
}

解析：

• rollbackFor:表示发生指定的异常一定回滚

• 处理逻辑：
  1）spring框架会先检查方法抛出的异常是不是在rollbackFor的属性值中，如果是异常在rollbackFor列表中，不管是什么类型的异常，一定回滚。
  2）如果你的抛出异常不在rollbackFor列表中，spring会判断异常是不是运行时异常，如果是一定回滚

10、使用AspectJ的AOP配置文件管理事务

• 使用注解配置管理事务的不足是，每个目标类都需要配置事务代理，当一个大型项目有很多类和方法时则需要大量的配置事务，配置文件会变得非常臃肿。
• 使用spring配置文件的方式可以自动为每个符合切入点表达式的类生成事务代理，其用法简单，只需在spring配置文件中声明类和方法需要的事务。

（1）在maven中加入依赖

<!--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）声明业务方法的事务属性（隔离级别、传播行为、超时时限）

<tx:advice id="myAdvice" transaction-manager="transactionManager">
    <!--<tx:attributes>:配置事务属性-->
    <tx:attributes>
        <!--tx:method：给具体的方法配置事务属性，method可以有多个，分别给不同的方法设置事务属性
            name：方法名称，1）完整的方法名称，不带有包和类
                            2）方法可以使用通配符，*表示任意字符
                                例如：buy*(buy开头的方法名称)
            propagation：传播行为，枚举值
            isolation：隔离级别
            rollback-for：你指定的异常类名，全限定类名。发生异常一定回滚
        -->
        <tx:method name="buy" propagation="REQUIRED" isolation="DEFAULT"
                   rollback-for="java.lang.NullPointerException,com.hcz.exception.NotEnoughException"/>
        <!--使用通配符，指定很多个方法-->
        <tx:method name="add*"/>
        <!--指定修改方法-->
        <tx:method name="modify"/>
        <!--指定其它方法等-->
        <tx:method name="*" propagation="SUPPORTS" read-only="true"/>
    </tx:attributes>
</tx:advice>

（4）配置AOP增强器：指定哪些哪类要创建代理

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

        com.hcz.service.Impl.buyGoodsServiceImpl
        com.crm.service.crmService
        com.service.otherService
    -->
    <aop:pointcut id="servicePt" expression="execution(* *..service..*.*(..))"/>

    <!--配置增强器:关联advice和pointcut-->
    <aop:advisor advice-ref="myAdvice" pointcut-ref="servicePt"/>
</aop:config>