Java--Spring事务
Posted MinggeQingchun
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java--Spring事务相关的知识，希望对你有一定的参考价值。
事务原本是数据库中的概念，在Dao层。但Spring框架将事务提升到业务层，即 Service 层
Spring事务的本质其实就是数据库对事务的支持
Spring支持编程式事务管理以及声明式事务管理两种方式
一、编程式事务管理
编程式事务管理是侵入性事务管理，使用TransactionTemplate或者直接使用PlatformTransactionManager，对于编程式事务管理，Spring推荐使用TransactionTemplate
二、声明式事务管理
声明式事务管理建立在AOP之上，其本质是对方法前后进行拦截，然后在目标方法开始之前创建或者加入一个事务，执行完目标方法之后根据执行的情况提交或者回滚。
编程式事务每次实现都要单独实现，但业务量大功能复杂时，使用编程式事务无疑是痛苦的，而声明式事务不同，声明式事务属于无侵入式，不会影响业务逻辑的实现，只需要在配置文件中做相关的事务规则声明或者通过注解的方式，便可以将事务规则应用到业务逻辑中。
显然声明式事务管理要优于编程式事务管理，这正是Spring倡导的非侵入式的编程方式。唯一不足的地方就是声明式事务管理的粒度是方法级别，而编程式事务管理是可以到代码块的，但是可以通过提取方法的方式完成声明式事务管理的配置。
事务定义接口 TransactionDefinition 中定义了事务描述相关的三类常量：事务隔离级别、事务传播行为、事务默认超时时限
事务隔离级别
这些常量均是以 ISOLATION_开头。即形如 ISOLATION_XXX
1、DEFAULT：采用 DB 默认的事务隔离级别。mysql 的默认为 REPEATABLE_READ； Oracle默认为 READ_COMMITTED
2、READ_UNCOMMITTED：读未提交。未解决任何并发问题
3、READ_COMMITTED：读已提交。解决脏读，存在不可重复读与幻读
4、REPEATABLE_READ：可重复读。解决脏读、不可重复读，存在幻读
5、SERIALIZABLE：串行化。不存在并发问题
事务传播行为
事务传播行为是指，处于不同事务中的方法在相互调用时，执行期间事务的维护情况。如，A 事务中的方法 doSome()调用 B 事务中的方法 doOther()，在调用执行期间事务的维护情况，就称为事务传播行为。事务传播行为是加在方法上的
事务传播行为常量都是以 PROPAGATION_ 开头，形如 PROPAGATION_XXX
1、PROPAGATION_REQUIRED
2、PROPAGATION_REQUIRES_NEW
3、PROPAGATION_SUPPORTS
4、PROPAGATION_MANDATORY
5、PROPAGATION_NESTED
6、PROPAGATION_NEVER
7、PROPAGATION_NOT_SUPPORTED
PROPAGATION_REQUIRED：
指定的方法必须在事务内执行。若当前存在事务，就加入到当前事务中；若当前没有事务，则创建一个新事务。这种传播行为是最常见的选择，也是 Spring 默认的事务传播行为。如该传播行为加在 doOther()方法上。若 doSome()方法在调用 doOther()方法时就是在事务内运行的，则 doOther()方法的执行也加入到该事务内执行。若 doSome()方法在调用doOther()方法时没有在事务内执行，则 doOther()方法会创建一个事务，并在其中执行
PROPAGATION_SUPPORTS
指定的方法支持当前事务，但若当前没有事务，也可以以非事务方式执行
PROPAGATION_REQUIRES_NEW
总是新建一个事务，若当前存在事务，就将当前事务挂起，直到新事务执行完毕
事务默认超时时限
表示一个方法最长的执行时间，如果方法执行时超过了时间，事务就回滚。单位是秒， 整数值， 默认是 -1
Spring事务回滚规则
Spring 事务的默认回滚方式是：发生运行时异常和 error 时回滚，发生受查(编译)异常时提交
Throwable 类是 Java 语言中所有错误或异常的超类
Error是程序在运行过程中出现的无法处理的错误，比如 OutOfMemoryError、ThreadDeath、NoSuchMethodError 等。当这些错误发生时，程序是无法处理（捕获或抛出），JVM 一般会终止线程
程序在编译和运行时出现的另一类错误称之为异常，它是 JVM 通知程序员的一种方式
异常分为运行时异常与受查异常
运行时异常，是 RuntimeException 类或其子类，即只有在运行时才出现的异常
NullPointerException、ArrayIndexOutOfBoundsException、IllegalArgumentException 等均属于
运行时异常。这些异常由 JVM 抛出，在编译时不要求必须处理（捕获或抛出）
受查异常，也叫编译时异常，即在代码编写时要求必须捕获或抛出的异常，若不处理，则无法通过编译。如 SQLException，ClassNotFoundException，IOException 等都属于受查异常
RuntimeException 及其子类以外的异常，均属于受查异常。自定义的 Exception的子类，即用户自定义的异常也属受查异常。程序员在定义异常时，只要未明确声明定义的为RuntimeException 的子类，那么定义的就是受查异常
事务管理器是 PlatformTransactionManager 接口对象
DataSourceTransactionManager：使用 JDBC 或 MyBatis 进行数据库操作时使用
HibernateTransactionManager：使用 Hibernate 进行持久化数据时使用
1、创建数据库，建一张商品good表和商品销售记录sale_good表
2、新建一个maven项目
3、加入maven的依赖
（1）spring依赖 （2）mybatis依赖 （3）mysql驱动 （4）spring的事务依赖 （5）mybatis和spring集成依赖
4、创建实体类
public class Goods
private Integer id;
private String goodName;
private Integer goodAmount;
private Float price;
public Integer getId()
return id;
public void setId(Integer id)
this.id = id;
public String getGoodName()
return goodName;
public void setGoodName(String goodName)
this.goodName = goodName;
public Integer getGoodAmount()
return goodAmount;
public void setGoodAmount(Integer goodAmount)
this.goodAmount = goodAmount;
public Float getPrice()
return price;
public void setPrice(Float price)
this.price = price;
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;
5、创建dao接口和mapper文件
public interface GoodsDao
//更新库存
//goods表示本次用户购买的商品信息， id， 购买数量
int updateGoods(Goods goods);
//查询商品的信息
Goods selectGoods(Integer id);
public interface SaleDao
//增加销售记录
int insertSale(Sale sale);
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.xx.dao.GoodsDao">
<resultMap id="goodMap" type="com.xx.domain.Goods">
<id column="id" property="id" />
<result column="good_name" property="goodName" />
<result column="good_amount" property="goodAmount" />
<result column="price" property="price" />
</resultMap>
<select id="selectGoods" resultMap="goodMap">
select id,good_name,good_amount,price
from good
where id = #gid
</select>
<update id="updateGoods">
update good
set good_amount = good_amount - #goodAmount
where id=#id
</update>
</mapper>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.xx.dao.SaleDao">
<insert id="insertSale">
insert into sale_good(gid,nums) values(#gid,#nums)
</insert>
</mapper>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：控制mybatis全局行为 -->
<!--<settings>
<!– 设置mybatis输出日志 –>
<setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>-->
<!-- 定义别名 -->
<typeAliases>
<!-- 第一种方式
指定一个类型为一个自定义别名
type：自定义类型的全限定名称
alias：别名
-->
<!-- <typeAlias type="com.mycompany.domain.User" alias="user" />-->
<!-- 第二种方式
<package>
name：包名，这个包中所有的类，类名就是别名（不区分大小写）
-->
<package name="com.mycompany.domain" />
</typeAliases>
<!--
数据源DataSource 放在spring配置文件中
-->
<!--<environments default="development">
<environment id="online">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/onlinedb"/>
<property name="username" value="root"/>
<property name="password" value="admin123456"/>
</dataSource>
</environment>
</environments>-->
<!-- sql mapper（SQL映射文件）的位置 -->
<mappers>
<!-- 第一种方式：指定多个mapper文件
一个mapper标签指定一个文件位置
从类路径开始（target/classes）
-->
<!-- <mapper resource="com/mycompany/dao/UserDao.xml" />-->
<!-- 第二种方式：使用包名
name：xml（mapper）文件所在的包名，这个包中所有xml文件一次都能加载给mybatis
使用package要求：
（1）mapper文件名称需要和接口名称一样（区分大小写）
（2）mapper文件和dao接口需要在同一目录
-->
<package name="com.mycompany.dao" />
</mappers>
</configuration>7、创建service接口和实现类，属性是dao
public interface BuyGoodService
//购买商品的方法， goodsId：购买商品的编号， nums：购买的数量
void buy(Integer goodsId,Integer nums);
8、创建spring的配置文件：声明mybatis对象交给spring创建 （1）数据源DataSource （2）SqlSessionFactory （3）Dao对象 （4）声明自定义的service
jdbc.properties数据库的属性配置文件
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssm
jdbc.user=root
jdbc.password=123456
jdbc.maxActive=209、创建测试类
public class TestTransaction
@Test
public void testTransaction()
String config = "applicationContext.xml";
ApplicationContext ac = new ClassPathXmlApplicationContext(config);
//获取容器中所有对象名
String names[] = ac.getBeanDefinitionNames();
for (String name:names)
System.out.println("容器中对象名称：" + name + " " + ac.getBean(name));
//从容器获取service
BuyGoodService service = (BuyGoodService) ac.getBean("buyGoodService");
//调用方法
service.buy(1001,10);
在 Spring 中通常可以通过以下两种方式来实现对事务的管理（如上步骤创建项目或者模块，如下两种方式区别之处在下面使用事务过程中会单独区分说明）
一、使用 Spring 的事务注解管理事务
@Transactional注解方案适合中小项目使用
spring框架用aop实现给业务方法增加事务的功能， 使用@Transactional注解增加事务
使用@Transactional的步骤：
1、需要声明事务管理器对象
<bean id="xx" class="DataSourceTransactionManager">2、开启事务注解驱动， 告诉spring框架，我要使用注解的方式管理事务
spring使用aop机制，创建@Transactional所在的类代理对象，给方法加入事务的功能
spring给业务方法加入事务：
在业务方法执行之前，先开启事务，在业务方法之后提交或回滚事务，使用aop的环绕通知
@Around("要增加的事务功能的业务方法名称")
Object myAround()
//spring开启事务
try
buy(1001,10);
spring的事务管理器.commit();
catch(Exception e)
spring的事务管理器.rollback();
通过@Transactional 注解方式，可将事务植入到相应 public 方法中，实现事务管理
@Transactional 的所有可选属性如下
propagation：用于设置事务传播属性。该属性类型为 Propagation 枚举，默认值为
Propagation.REQUIRED。
isolation：用于设置事务的隔离级别。该属性类型为 Isolation 枚举，默认值为
Isolation.DEFAULT
readOnly：用于设置该方法对数据库的操作是否是只读的。该属性为 boolean，默认值
为 false
timeout：用于设置本操作与数据库连接的超时时限。单位为秒，类型为 int，默认值为
-1，即没有时限
rollbackFor：指定需要回滚的异常类。类型为 Class[]，默认值为空数组。当然，若只有
一个异常类时，可以不使用数组
rollbackForClassName：指定需要回滚的异常类类名。类型为 String[]，默认值为空数组。
当然，若只有一个异常类时，可以不使用数组
noRollbackFor：指定不需要回滚的异常类。类型为 Class[]，默认值为空数组。当然，若
只有一个异常类时，可以不使用数组
noRollbackForClassName：指定不需要回滚的异常类类名。类型为 String[]，默认值为空
数组。当然，若只有一个异常类时，可以不使用数组
注：
1、@Transactional 若用在方法上，只能用于 public 方法上。对于其他非public方法，如果加上了注解@Transactional，虽然 Spring 不会报错，但不会将指定事务植入到该方法中。Spring 会忽略掉所有非 public 方法上的@Transaction 注解
2、若@Transaction 注解在类上，则表示该类上所有的方法均将在执行时植入事务
第2步加入依赖
<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>
<!-- spring和mybatis集成依赖 -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>2.0.1</version>
</dependency>
<!-- mysql驱动 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.9</version>
</dependency>
<!-- 阿里数据库连接池Druid -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.2.6</version>
</dependency>
</dependencies>第7步创建service类和实现类；主要使用@Transactional注解
public class BuyGoodServiceImpl implements BuyGoodService
private SaleDao saleDao;
private GoodsDao goodsDao;
public void setSaleDao(SaleDao saleDao)
this.saleDao = saleDao;
public void setGoodsDao(GoodsDao goodsDao)
this.goodsDao = goodsDao;
/**
rollbackFor：表示发生的指定异常一定回滚
原理：
（1）spring框架首先会检查方法抛出的异常是不是在rollbackFor的属性值中
如果异常在rollbackFor列表中，不管什么类型异常，一定回滚
（2）如果抛出的异常不在rollbackFor列表中，spring会判断异常是不是RuntimeException
如果是一定回滚
*/
/*@Transactional(
propagation = Propagation.REQUIRED,//事务传播行为
isolation = Isolation.DEFAULT,//事务隔离级别
readOnly = false,//对数据库的操作是否是只读
rollbackFor = //指定需要回滚的异常类。类型为 Class[]，默认值为空数组
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.getGoodAmount() < nums)
//商品库存不足
throw new NotEnoughException("编号是："+goodsId+",商品库存不足");
//修改库存了
Goods buyGoods = new Goods();
buyGoods.setId( goodsId);
buyGoods.setGoodAmount(nums);
goodsDao.updateGoods(buyGoods);
System.out.println("=====buy方法的结束====");
第8步，创建spring配置文件；主要使用<tx:annotation-driven>
这里要特别注意<tx:annotation-driven>的选择
<?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加载数据库的属性配置文件
-->
<context:property-placeholder location="classpath:jdbc.properties" />
<!--1、声明数据源DataSource，作用：连接数据库
将mybatis主配置文件 configuration 下的environments 标签内容移到了这里
Druid官网：https://github.com/alibaba/druid
DruidDataSource配置：https://github.com/alibaba/druid/wiki/DruidDataSource%E9%85%8D%E7%BD%AE
-->
<bean id="myDataSource" class="com.alibaba.druid.pool.DruidDataSource"
init-method="init" destroy-method="close">
<!-- set注入给DruidDataSource提供数据库连接信息 -->
<!-- 使用属性配置文件中的数据，语法 $key -->
<property name="url" value="$jdbc.url" />
<property name="username" value="$jdbc.user" />
<property name="password" value="$jdbc.password" />
<property name="maxActive" value="$jdbc.maxActive" />
</bean>
<!--2、声明mybatis中提供的SqlSessionFactoryBean类 -->
<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>
<!--3、创建dao对象，使用SqlSession的getMapper(xxDao.class)
MapperScannerConfigurer：内部调用getMapper()方法生成每个dao接口的代理对象
-->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<!-- 指定SqlSession对象的id -->
<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
<!-- 指定包名，dao接口所在的包名
MapperScannerConfigurer会扫描这个包中的所有接口，把每个接口都执行一次getMapper()方法，
得到每个接口的dao对象
创建好的dao对象放入到spring容器中；dao对象的默认名称是 接口名首字母小写！！！
-->
<property name="basePackage" value="com.mycompany.dao" />
</bean>
<!--4、声明service -->
<bean id="buyGoodService" class="com.mycompany.service.impl.BuyGoodServiceImpl">
<!-- 通过MapperScannerConfigurer 扫描包；dao对象的默认名称是 接口名首字母小写！！！ -->
<property name="saleDao" ref="saleDao" />
<property name="goodsDao" ref="goodsDao" />
</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 需要选择 http://www.springframework.org/schema/tx
-->
<tx:annotation-driven transaction-manager="transactionManager" />
</beans>二、使用 AspectJ 的 AOP 配置管理事务
适合大型项目，有很多的类，方法，需要大量的配置事务，使用aspectj框架功能，在spring配置文件中声明类，方法需要的事务。这种方式业务方法和事务配置完全分离
实现步骤： 都是在xml配置文件中实现
1、使用的是aspectj框架，需要加入依赖
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>5.2.5.RELEASE</version>
</dependency>2、声明事务管理器对象
<bean id="xx" class="DataSourceTransactionManager">3、声明方法需要的事务类型（配置方法的事务属性【隔离级别，传播行为，超时】）
4、配置aop：指定哪些哪类要创建代理
第2步加入依赖；变化：加入了aspectj依赖
<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>
<!--aspectj依赖-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</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>
<!-- spring和mybatis集成依赖 -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>2.0.1</version>
</dependency>
<!-- mysql驱动 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.9</version>
</dependency>
<!-- 阿里数据库连接池Druid -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.2.6</version>
</dependency>
</dependencies>第7步创建service类和实现类；没有使用@Transactional注解
public class BuyGoodServiceImpl implements BuyGoodService
private SaleDao saleDao;
private GoodsDao goodsDao;
public void setSaleDao(SaleDao saleDao)
this.saleDao = saleDao;
public void setGoodsDao(GoodsDao goodsDao)
this.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.getGoodAmount() < nums)
//商品库存不足
throw new NotEnoughException("编号是："+goodsId+",商品库存不足");
//修改库存了
Goods buyGoods = new Goods();
buyGoods.setId( goodsId);
buyGoods.setGoodAmount(nums);
goodsDao.updateGoods(buyGoods);
System.out.println("=====buy方法的结束====");
第8步，创建spring配置文件；主要使用<tx:advice>和<aop:config>
这里需要注意选择<tx:advice>
<?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" xmlns:util="http://www.springframework.org/schema/util"
xmlns:aop="http://www.springframework.org/schema/aop"
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 http://www.springframework.org/schema/util https://www.springframework.org/schema/util/spring-util.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
<!--
spring加载数据库的属性配置文件
-->
<context:property-placeholder location="classpath:jdbc.properties" />
<!--1、声明数据源DataSource，作用：连接数据库
将mybatis主配置文件 configuration 下的environments 标签内容移到了这里
Druid官网：https://github.com/alibaba/druid
DruidDataSource配置：https://github.com/alibaba/druid/wiki/DruidDataSource%E9%85%8D%E7%BD%AE
-->
<bean id="myDataSource" class="com.alibaba.druid.pool.DruidDataSource"
init-method="init" destroy-method="close">
<!-- set注入给DruidDataSource提供数据库连接信息 -->
<!-- 使用属性配置文件中的数据，语法 $key -->
<property name="url" value="$jdbc.url" />
<property name="username" value="$jdbc.user" />
<property name="password" value="$jdbc.password" />
<property name="maxActive" value="$jdbc.maxActive" />
</bean>
<!--2、声明mybatis中提供的SqlSessionFactoryBean类 -->
<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>
<!--3、创建dao对象，使用SqlSession的getMapper(xxDao.class)
MapperScannerConfigurer：内部调用getMapper()方法生成每个dao接口的代理对象
-->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<!-- 指定SqlSession对象的id -->
<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
<!-- 指定包名，dao接口所在的包名
MapperScannerConfigurer会扫描这个包中的所有接口，把每个接口都执行一次getMapper()方法，
得到每个接口的dao对象
创建好的dao对象放入到spring容器中；dao对象的默认名称是 接口名首字母小写！！！
-->
<property name="basePackage" value="com.mycompany.dao" />
</bean>
<!--4、声明service -->
<bean id="buyGoodService" class="com.mycompany.service.impl.BuyGoodServiceImpl">
<!-- 通过MapperScannerConfigurer 扫描包；dao对象的默认名称是 接口名首字母小写！！！ -->
<property name="saleDao" ref="saleDao" />
<property name="goodsDao" ref="goodsDao" />
</bean>
<!-- 声明式事务处理：和源代码完全分离 -->
<!--1、声明事务管理器对象-->
<bean id="treansactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!-- 连接的数据库，指定数据源 -->
<property name="dataSource" ref="myDataSource" />
</bean>
<!--2、声明业务方法的事务属性（隔离级别，传播行为，超时时间等）
id：自定义名称；表示 <tx:advice>和</tx:advice>之间的配置内容
transaction-manager:事务管理器对象的id
tx:advice 需要选择 http://www.springframework.org/schema/tx
-->
<tx:advice id="myAdvice" transaction-manager="treansactionManager">
<!-- 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.mycompany.exception.NotEnoughException"/>
<!-- 使用通配符，指定 -->
<tx:method name="add*" />
</tx:attributes>
</tx:advice>
<!-- 配置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>
</beans>我们没使用事务，会发现商品库存没有减少，但是新增了销售记录
使用事务机制之后，会发现库存没有减少，但是商品销售记录表的id由12增到了15，是因为中间运行了两次异常，一次为库存不足异常，一次为商品不存在异常
以上是关于Java--Spring事务的主要内容，如果未能解决你的问题，请参考以下文章