Spring的事务处理------anno

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

    使用@Transactional的步骤：
    1.需要声明事务管理器对象
        <bean id="xx" class="DataSourceTransactionManager">
    
    2.开启事务注解驱动，告诉Spring框架，我要使用注解的方式管理事务。
        Spring使用aop的机制，创建@Transactional所在类代理的对象，给方法加入事务的功能。
        spring给业务方法加入事务：
            在你的业务方法执行之前，先开启事务，在业务方法之后提交或回滚事务，使用aop的环绕通知.
        
            @Around("你要增加的事务功能的业务方法名称")
            Object MyAround(){
                开启事务，spring给你开启
                try{
                    spring的事务管理.commit();
                }catch(Exception e){
                    spring的事务管理.rollback();
                }
            }

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

ServiceImpI 

package edu.tjdz.service.ImpI;

import edu.tjdz.dao.GoodsDao;
import edu.tjdz.dao.SaleDao;
import edu.tjdz.domain.Goods;
import edu.tjdz.domain.Sale;
import edu.tjdz.exce.NotEnoughException;
import edu.tjdz.service.BuyGoodsService;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

public class BuyGoodsServiceImpl implements BuyGoodsService {

    private SaleDao saleDao;
    private GoodsDao goodsDao;

    /**
     *
     * 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方法的开始====");
        //记录销售信息，向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 void setSaleDao(SaleDao saleDao) {
        this.saleDao = saleDao;
    }

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

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"
       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提供连接数据库的信息-->
        <!--
            使用属性配置文件中的数据，语法 ${key}
        -->
        <property name="url" value="${jdbc.url}"/><!--setUrl()-->
        <property name="username" value="${jdbc.username}"/>
        <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对象，使用SqlSessionFactory的getMapper(StudentDao.class)
        MapperScannerConfigurer:在内部调用getMapper()生成每个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="edu.tjdz.dao"/>
    </bean>

    <!--声明service-->
    <bean id="buyService" class="edu.tjdz.service.ImpI.BuyGoodsServiceImpl">
        <property name="goodsDao" ref="goodsDao"/>
        <property name="saleDao" ref="saleDao"/>
    </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 transaction-manager="transactionManager"/>
</beans>