文章目录：

2.5 编写dao接口和对应的mapper映射文件

2.5.1 商品实体类Goods对应的dao接口和mapper文件

package com.bjpowernode.dao;
import com.bjpowernode.entity.Goods;
/**
 *
 */
public interface GoodsDao {
    //查询某个id的商品信息，返回的是Goods对象（商品类）
    Goods selectById(Integer id);
    //参数goods表示本次购买的商品id和amount购买数量
    int updateGoods(Goods goods);
}

<?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.bjpowernode.dao.GoodsDao">
    <!-- 使用insert、update、delete、select标签编写sql语句 -->
    <select id="selectById" resultType="com.bjpowernode.entity.Goods">
        select id,name,amount,price
        from goods
        where id = #{id}
    </select>
    <update id="updateGoods">
        update goods
        set amount = amount - #{amount}
        where id = #{id}
    </update>
</mapper>

2.5.2 销售记录实体类Sale对应的dao接口和mapper文件

package com.bjpowernode.dao;
import com.bjpowernode.entity.Sale;
/**
 *
 */
public interface SaleDao {
    int insertSale(Sale sale);
}

<?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.bjpowernode.dao.SaleDao">
    <!-- 使用insert、update、delete、select标签编写sql语句 -->
    <insert id="insertSale">
        insert into sale(gid,num) values(#{gid},#{num})
    </insert>
</mapper>

2.6 编写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>
    <!-- 设置日志 -->
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>
    <mappers>
<!--        <mapper resource=""/>-->
        <package name="com.bjpowernode.dao"/>
    </mappers>
</configuration>

2.7 定义异常类（运行时异常）

这个异常类主要用来处理购买商品时，库存、商品是否存在这些情况下，所发生的异常信息。

package com.bjpowernode.excetion;
/**
 *  运行时异常
 */
public class NotEnoughException extends RuntimeException {
    public NotEnoughException() {
        super();
    }
    public NotEnoughException(String message) {
        super(message);
    }
}

2.8 定义Service接口和对应的实现类

package com.bjpowernode.service;
/**
 *
 */
public interface BuyGoodsService {
    /**
     * @param goodsId: 购买的商品id
     * @param num: 购买的商品数量
     */
    void buy(Integer goodsId,Integer num);
}

2.8.1 Spring使用注解（@Transactional）控制事务

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

1. propagation：用于设置事务传播属性。该属性类型为 Propagation 枚举，默认值为 Propagation.REQUIRED。

2. isolation：用于设置事务的隔离级别。该属性类型为 Isolation 枚举，默认值为 Isolation.DEFAULT。

3. readOnly：用于设置该方法对数据库的操作是否是只读的。该属性为 boolean，默认值为 false。

4. timeout：用于设置本操作与数据库连接的超时时限。单位为秒，类型为 int，默认值为-1，即没有时限。

5. rollbackFor：指定需要回滚的异常类。类型为 Class[]，默认值为空数组。当然，若只有一个异常类时，可以不使用数组。

6. rollbackForClassName：指定需要回滚的异常类类名。类型为 String[]，默认值为空数组。当然，若只有一个异常类时，可以不使用数组。

7. noRollbackFor：指定不需要回滚的异常类。类型为 Class[]，默认值为空数组。当然，若只有一个异常类时，可以不使用数组。

8.noRollbackForClassName：指定不需要回滚的异常类类名。类型为 String[]，默认值为空数组。当然，若只有一个异常类时，可以不使用数组。

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

package com.bjpowernode.service.impl;
import com.bjpowernode.dao.GoodsDao;
import com.bjpowernode.dao.SaleDao;
import com.bjpowernode.entity.Goods;
import com.bjpowernode.entity.Sale;
import com.bjpowernode.excetion.NotEnoughException;
import com.bjpowernode.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;
    public void setSaleDao(SaleDao saleDao) {
        this.saleDao = saleDao;
    }
    public void setGoodsDao(GoodsDao goodsDao) {
        this.goodsDao = goodsDao;
    }
    /**
     *  @Transactional 注解放在public业务方法的上面，表示方法有事务功能
     *  propagation = Propagation.REQUIRED: 设置事务的传播属性，默认值
     *  isolation = Isolation.DEFAULT: 设置事物的隔离级别，默认值
     *  readOnly = false: 对数据库的操作不是只读的
     *  timeout = 20: 超时时限设置为20s
     *  rollbackFor = {NullPointerException.class,NotEnoughException.class}): //两个异常发生任何一个，则执行回滚操作
     *  框架首先检查方法抛出的异常是不是在rollback的数组中，如果在，一定执行回滚。
     *  如果不在，框架会继续检查抛出的异常是不是RuntimeException，如果是，仍然执行回滚。
     */
    @Transactional(propagation = Propagation.REQUIRED,
                    isolation = Isolation.DEFAULT,
                    readOnly = false,
                    timeout = 20,
                    rollbackFor = {NullPointerException.class,NotEnoughException.class})
    @Override
    public void buy(Integer goodsId, Integer num) {
        System.out.println("=====buy方法的开始======");
        //生成销售记录
        Sale sale=new Sale();
        sale.setGid(goodsId);
        sale.setNum(num);
        saleDao.insertSale(sale);
        //查询商品
        Goods goods=goodsDao.selectById(goodsId);
        if (goods == null) {
            throw new NullPointerException(goodsId + "商品不存在。");
        }else if (goods.getAmount() < num) {
            throw new NotEnoughException(goodsId + "商品库存不足。");
        }
        //更新库存
        Goods buyGoods=new Goods();
        buyGoods.setId(goodsId);
        buyGoods.setAmount(num);
        goodsDao.updateGoods(buyGoods);
        System.out.println("=====buy方法的完成======");
    }
}

2.9 定义Spring配置文件

2.9.1 引入外部属性配置文件（jdbc.properties）

jdbc.url=jdbc:mysql://localhost:3306/ssm?useUnicode=true&amp;characterEncoding=utf-8
jdbc.username=root
jdbc.password=12345678

<context:property-placeholder location="classpath:jdbc.properties" />

2.9.2 声明数据源、SqlSessionFactory对象、读取mapper文件

<bean id="myDataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
    <property name="url" value="${jdbc.url}" />
    <property name="username" value="${jdbc.username}" />
    <property name="password" value="${jdbc.password}" />
</bean>
<bean id="factory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="myDataSource" />
    <property name="configLocation" value="classpath:mybatis.xml" />
</bean>
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="sqlSessionFactoryBeanName" value="factory" />
    <property name="basePackage" value="com.bjpowernode.dao" />
</bean>

2.9.3 声明Service业务层对象

<bean id="buyGoodsService" class="com.bjpowernode.service.impl.BuyGoodsServiceImpl">
    <property name="goodsDao" ref="goodsDao" />
    <property name="saleDao" ref="saleDao" />
</bean>

2.9.4 声明事务管理器、开启事务注解驱动

<!-- 声明事务的控制 -->
<!-- 声明事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <!-- 指定数据源DataSource -->
    <property name="dataSource" ref="myDataSource" />
</bean>
<!--
    开启事务注解驱动，告诉框架使用注解管理事务
    transaction-manager: 指定事务管理器的id
-->
<tx:annotation-driven transaction-manager="transactionManager" />

2.10 定义测试类

2.10.1 测试方法1

service.buy(1001，10)；表示我们此时要购买1001号商品10台。

@Test
public void test01() {
    ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
    BuyGoodsService service= (BuyGoodsService) ctx.getBean("buyGoodsService");
    service.buy(1001,10);
}

这里的 id 等于5，是因为在这之前，我做了几次代码测试，sale表中的主键（销售记录编号）是自增的，所以这里是5。

后面的 gid=1001，num=10，表示编号为1001的商品，卖出了10台。

2.10.2 测试方法2

service.buy(1002，200)；表示我们此时要购买1002号商品200台。（而数据库中1002号商品总库存只有50台，所以这里会发生异常）

@Test
public void test02() {
    ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
    BuyGoodsService service= (BuyGoodsService) ctx.getBean("buyGoodsService");
    service.buy(1002,200);
}

这里产生的异常是我们自定义的NotEnoughException 异常。所以事务一定执行回滚。

2.10.3 测试方法3

service.buy(1005，20)；表示我们此时要购买1005号商品20台。（而数据库中并不存在1005号商品，所以这里会发生异常）

@Test
public void test03() {
    ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
    BuyGoodsService service= (BuyGoodsService) ctx.getBean("buyGoodsService");
    service.buy(1005,20);
}

这里产生的异常是Java中Exception类下的NullPointerException 异常。所以事务一定执行回滚。

4.使用AspectJ框架控制事务

使用这种方法控制事务的步骤如下：

1. 在pom.xml中加入 spring-aspects 依赖

2. 在spring配置文件中声明事务的内容：①声明事务管理器；②声明业务方法需要的事务属性；③声明切入点表达式。

与上面使用注解（@Transactional）相比，大部分代码都是一样的。只有Spring的配置文件中有所改动。

将第一种方法中spring配置文件中的声明事务注解驱动删掉，换成下面的代码就可以了。

    <!--
        声明业务方法的事务属性(隔离级别、传播行为、超时时限)
        id: 给业务方法配置事务段代码起个名称，唯一值
        transaction-manager: 事务管理器的id
    -->
    <tx:advice id="serviceAdvice" transaction-manager="transactionManager">
        <!-- 给具体的业务方法增加事务的说明 -->
        <tx:attributes>
            <!-- name的值: 1)业务方法的名称 2)带有通配符* -->
            <tx:method name="buy"
                       propagation="REQUIRED"
                       isolation="DEFAULT"
                       timeout="20"
                       read-only="false"
                       rollback-for="java.lang.NullPointerException,com.bjpowernode.excetion.NotEnoughException"/>
        </tx:attributes>
    </tx:advice>
    <!-- 声明切入点表达式，表示哪些包中的类、方法需要添加事务 -->
    <aop:config>
        <!--
            id: 切入点表达式的名称，唯一值
            expression: 切入点表达式
        -->
        <aop:pointcut id="servicePointcut" expression="execution(* *..service..*.*(..))" />
        <aop:advisor advice-ref="serviceAdvice" pointcut-ref="servicePointcut" />
    </aop:config>

5.两种方式各自的使用特点

一、使用@Transactional注解

1. Spring框架自己提供的事务控制。

2. 适合中小型项目。

3. 使用方便，效率高。

二、使用AspectJ框架

1. 缺点：理解难，配置复杂。

2. 优点：代码和事务配置是分开的。控制事务，其源代码不用修改。能快速的了解和掌控项目的全部事务，适合大型项目。

Spring——Spring中的事务、使用注解（@Transactional）控制事务、使用AspectJ框架控制事务（下）

文章目录：

4.使用AspectJ框架控制事务

5.两种方式各自的使用特点

热门文章

最新文章

相关课程

相关电子书

相关实验场景

Spring——Spring中的事务、使用注解（@Transactional）控制事务、使用AspectJ框架控制事务 （下）

文章目录：

4.使用AspectJ框架控制事务

5.两种方式各自的使用特点

热门文章

最新文章

相关课程

相关电子书

相关实验场景

Spring——Spring中的事务、使用注解（@Transactional）控制事务、使用AspectJ框架控制事务（下）