Spring事务使用

Spring事务

一、Spring的事务管理

​ 事务原本是数据库中的概念，在Dao层。但一般情况下，需要将事务提升到业务层，即Service层。这样做是为了能够使用事务的特性来管理具体的业务。

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

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

二、Spring事务管理API

​ Spring的事务管理，主要用到两个事务相关的接口

1、事务管理器接口（重点）

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

（1）常用的两个实现类

PlatformTransactionManager接口有两个常用的实现类

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

（2）Spring的回滚方式

​ Spring事务的默认回滚方式是：发生运行时异常和error 时回滚，发生受查（编译）异常时提交。不过，对于受查异常，程序员也可以手工设置其回滚方式。

（3）回顾错误与异常

​ Throwable类是 Java语言中所有错误或异常的超类。只有当对象是此类（或其子类之一）的实例时，才能通过 Java虛拟机或者 Java的 throw语句抛出。

​ Error是程序在运行过程中出现的无法处理的错误，比如OutOfMemoryError 、ThreadDeath、NoSuchMethodError 等。当这些错误发生时，程序是无法处理（捕获或抛出）的，JVM一般会终止线程。

​ 程序在编译和运行时出现的另一类错误称之为异常，它是 JVM通知程序员的一种方式。通过这种方式，让程序员知道已经或可能出现错误，要求程序员对其进行处理。

​ 异常分为运行时异常与受查异常。

• 运行时异常，是RuntimeException 类或其子类，即只有在运行时才出现的异常。如，NullPointerException、ArraylndexOutOfBoundsException、llegalArgumentException 等均属于运行时异常。这些异常由JVM抛出，在编译时不要求必须处理（捕获或抛出）。但，只要代码编写足够仔细，程序足够健壮，运行时异常是可以避免的。
• 受查异常，也叫编译时异常，即在代码编写时要求必须捕获或抛出的异常，若不处理，则无法通过编译。如SQLException, ClassNotFoundException、lOException 等都属于受查异常。
  • RuntimeException及其子类以外的异常，均属于受查异常。当然，用户自定义的Exception的子类，即用户自定义的异常也属受查异常。程序员在定义异常时，只要未明确声明定义的为RuntimeException的子类，那么定义的就是受查异常。

2、事务定义接口

​ 事务内部提交，回滚事务，使用的事务管理器对象，代替你完成commit，rollback。事务管理器是一个接口和他的众多实现类。

接口：platformTransactionManager ，定义了事务重要方法commit，rollback

实现类：spring把每一种数据库访问技术对应的事务处理类都创建好了

• mybatis 访问数据库 ------- spring创建好的是 DataSourceTransactionManager
• hibernate 访问数据库 ------- spring创建的是 HibernateTransactionManager

例如，要使用mybatis 访问数据库，则应该在xml 配置文件中配置如下程序

<bean id="xxx" class="...DataSourceTransactionManager">

​ 事务定义接口TransactionDefinition中定义了事务描述相关的三类常量：事务隔离级别、事务传播行为、事务默认超时时限，及对它们的操作。

（1）定义了五个事务隔离级别常量

​ 这些常量均是以 ISOLATION_ 开头。即形如 ISOLATION_XXX

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

（2）定义了七个事务传播行为常量

​ 所谓事务传播行为是指，处于不同事务中的方法在相互调用时，执行期间事务的维护情况。如，A事务中的方法doSome() 调用B事务中的方法doOther()，在调用执行期间事务的维护情况，就称为事务传播行为。事务传播行为是加在方法上的。

​ 事务传播行为常量都是以PROPAGATION_ 开头， 形如 PROPAGATION_ XXX

• PROPAGATION_REQUIRED（掌握）

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

  ​ 如该传播行为加在doOther() 方法上。若doSome() 方法在调用doOther() 方法时就是在事务内运行的，则doOther() 方法的执行也加入到该事务内执行。若doSome() 方法在调用doOther() 方法时没有在事务内执行，则doOther() 方法会创建一个事务， 并在其中执行
  

• PROPAGATION_REQUIRES_NEW（掌握）

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

• PROPAGATION_SUPPORTS（掌握）

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

• PROPAGATION_MANDATORY

• PROPAGATION_NESTED

• PROPAGATION_NEVER

• PROPAGATION_NOT_SUPPORTED

（3）定义了一个事务的超时时间

• TIMEOUT_DEFAULT

  表示一个方法最长的执行时间，如果方法执行时超过了时间，事务就回滚。单位是秒，整数值，默认是-1

（4）事务提交事务，回滚事务的时机

• 当业务方法，执行成功，没有异常抛出，当方法执行完毕，spring 在方法执行后提交事务。调用事务管理器commit
• 当业务方法抛出运行时异常或ERROR，spring执行回滚，调用事务管理器 rollback
  运行时异常的定义：RuntimeException 和他的子类都是运行时异常，例如 NullPointException、NumberFormatExcept
• 当业务方法抛出非运行时异常，主要是受查异常时，提交事务
  受查异常：在写代码中，必须处理的异常。例如 IOException、SQLException

3、spring事务的总结

（1）管理事务的是事务管理和他的实现类

（2）spring的事务是一个统一模型

• 指定要使用的事务管理器实现类，使用<bean>
• 指定哪些类，哪些方法需要加入事务的功能
• 指定方法需要的隔离级别，传播行为，超时
  你需要告诉spring，你的项目中类信息，方法的名称，方法的事务传播行为

三、程序举例环境搭建

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

1、创建数据库表

（1）sale（销售表）

注意：id为自增字段

（2）goods（商品表）

2、maven依赖pom.xml

<?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>cn.edu.huat</groupId>
  <artifactId>ch05-spring-trans</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依赖-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.2.6.RELEASE</version>
    </dependency>

    <!--spring事务-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>5.2.6.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>5.2.6.RELEASE</version>
    </dependency>

    <!--mybatis依赖-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.4</version>
    </dependency>

    <!--mybatis和spring集成的依赖-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>1.3.2</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>
    <!--目的是把src/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>
  </build>
</project>

3、创建实体类

（1）Sale

package cn.edu.huat.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;
    }
}

（2）Goods

package cn.edu.huat.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;
    }
}

4、定义dao接口

（1）SaleDao

package cn.edu.huat.dao;

import cn.edu.huat.domain.Sale;

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

（2）GoodsDao

package cn.edu.huat.dao;

import cn.edu.huat.domain.Goods;

public interface GoodsDao {
    //更新库存
    int updateGoods(Goods goods);

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

5、定义dao接口对应的sql映射文件

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

（2）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="cn.edu.huat.dao.GoodsDao">
    <select id="selectGoods" resultType="Goods">
        select * from goods where id=#{gid}
    </select>

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

6、定义异常类

package cn.edu.huat.exception;

public class NotEnoughException extends RuntimeException {
    public NotEnoughException() {
        super();
    }

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

7、定义Service接口

package cn.edu.huat.service;

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

8、定义service的实现类

package cn.edu.huat.service.impl;

import cn.edu.huat.dao.GoodsDao;
import cn.edu.huat.dao.SaleDao;
import cn.edu.huat.domain.Goods;
import cn.edu.huat.domain.Sale;
import cn.edu.huat.exception.NotEnoughException;
import cn.edu.huat.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("如今" + goods.getName() +"的库存还有" + (goods.getAmount() - buyGoods.getAmount()) + "个");
        System.out.println("===buy方法的完成===");
    }

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

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

9、定义Spring配置文件内容

（1）mybatis-config.xml

<?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="cn.edu.huat.domain" />
    </typeAliases>

    <!--sql mapper(sql映射文件)的位置-->
    <mappers>
        <!--name:包名，这个包中的所有mapper.xml一次都能加载-->
        <package name="cn.edu.huat.dao"/>
    </mappers>
</configuration>

（2）applicationContext.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"
       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">

    <!--把数据库的配置信息，写在一个独立的文件，编译修改数据库的配置内容
        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.username}" />
        <property name="password" value="${jdbc.password}" />
        <!--配置最大连接数量-->
        <property name="maxActive" value="${maxActive}" />
    </bean>

    <!--声明的是mybatis中提供的SqlSessionFactoryBean类，这个类内部创建qlSessionFactory-->
    <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-config.xml" />
    </bean>

    <!--创建dao对象，使用SqlSession的getMapper(userDao.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="cn.edu.huat.dao" />
    </bean>

    <!--声明service-->
    <bean id="buyService" class="cn.edu.huat.service.impl.BuyGoodsServiceImpl">
        <property name="goodsDao" ref="goodsDao" />
        <property name="saleDao" ref="saleDao" />
    </bean>
</beans>

10、定义测试类

package cn.edu.huat;

import cn.edu.huat.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(1002,10);
    }
}

（1）查看结果

（2）查看销售表记录

（3）查看商品表的库存

四、使用Spring的事务注解管理事务(掌握)

​ 通过==@Transactional== 注解方式，可将事务织入到相应public方法中，实现事务管理。

​ 适合中小项目使用，注解方案。

​ 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方法上的@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、在方法的上面加入@Trancational

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

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

处理逻辑是：

• spring框架会首先检查方法抛出的异常是不是在 rollbackFor的属性值中，如果异常在 rollbackFor列表中，不管是什么类型的异常，一定回滚
• 如果抛出的异常不在 rollbackFor列表中，spring会判断异常是不是RuntimeException，如果是则一定回滚

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

4、测试

（1）当库存不足时

（2）当有库存时

注意：中间 id为7的是刚刚测试库存不足时事务回滚，执行插入语句时后遇到异常撤销回去，因此没在数据库显示，但由于 id是自增，所以再测试时 id已经为8了。

五、使用AspecJ的AOP配置管理事务(掌握)

​ 使用XML 配置事务代理的方式的不足是，每个目标类都需要配置事务代理。当目标类较多，配置文件会变得非常臃肿。

​ 使用XML 配置顾问方式可以自动为每个符合切入点表达式的类生成事务代理。其用法很简单，只需将前面代码中关于事务代理的配置删除，再替换为如下内容即可。

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

1、复制项目

​ 在本文中第三大点的项目基础上进行修改

2、maven依赖pom.xml

​ 新加入aspectJ 的依赖坐标

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

3、在容器中添加事务管理器

<!--声明事务处理:和源代码完全分离-->
<!--1.声明事务管理器对象-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="myDataSource" />
</bean>

4、配置事务通知

<!--2.声明业务方法它的事务属性(隔离级别，传播行为，超时时间)
        id:自定义名称,表示<tx:advice>和</tx:advice>之间配置内容的
        transaction-manager:事务管理器对象的id-->
<tx:advice id="myAdvice" transaction-manager="transactionManager">
    <!--tx:attributes:配置事务属性-->
    <tx:attributes>
    	<tx:method name="buy" propagation="REQUIRED" isolation="DEFAULT" rollback-for="java.lang.NullPointerException,cn.edu.huat.exception.NotEnoughException" />
    </tx:attributes>
</tx:advice>

解析：

tx:method：给具体的方法配置事务属性，method可以有多个，分别给不同的方法设置事务

• name：方法名称

  • 完整的方法名称，不带有包和类
  • 方法可以使用通配符，*表示任意字符

• propagation：传播行为，枚举值
  isolation：隔离级别
  rollback-for：你指定的异常类名，全限定类名。发生异常一定回滚

5、配置增强器

<!--配置aop-->
<aop:config>
    <aop:pointcut id="servicePt" expression="execution(* *..servece..*.*(..))"/>
    <aop:advisor advice-ref="myAdvice" pointcut-ref="servicePt" />
</aop:config>

解析：

配置切入点表达式：指定哪些包中类，要使用事务

• id：切入点表达式的名称，唯一值
• expression：切入点表达式，指定哪些类要使用事务，aspectJ 会创建代理对象

配置增强器：关联adivce 和 pointcut

• advice-ref：通知，上面tx:advice那里的配置
• pointcut-ref：切入点表达式的 id

6、定义测试类

package cn.edu.huat;

import cn.edu.huat.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,10);
    }
}

（1）查看结果

（2）查看商品表的库存