Spring AOP与事务控制
本文深入探讨Spring框架中的AOP（面向切面编程）原理与应用，包括动态代理技术、Spring AOP配置、基于XML和注解的AOP实现，以及Spring中的事务管理机制，涵盖事务控制的API介绍、声明式事务控制的配置方法。
Spring学习笔记
AOP的相关概念
AOP概述
什么是AOP
- AOP：全称是 Aspect Oriented Programming 即：面向切面编程。
- 简单的说它就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，对我们的已有方法进行增强。
AOP的作用及优势
- 作用
- 在程序运行期间，不修改源码对已有方法进行增强。
- 优势
- 减少重复代码
- 提高开发效率
- 维护方便
AOP的实现方式
- 使用动态代理技术
AOP的具体应用
动态代理回顾
-
动态代理的特点
- 字节码随用随创建，随用随加载。
- 它与静态代理的区别也在于此。因为静态代理是字节码一上来就创建好，并完成加载。
- 装饰者模式就是静态代理的一种体现
-
动态代理常用的两种方式
- 基于接口的动态代理
- 提供者：JDK 官方的 Proxy 类。
- 要求：被代理类最少实现一个接口。
- 基于子类的动态代理
- 提供者：第三方的 CGLib，如果报 asmxxxx 异常，需要导入 asm.jar。
- 要求：被代理类不能用 final 修饰的类（最终类）。
- 基于接口的动态代理
-
使用JDK官方的Proxy类创建代理对象
-
一个演员的例子：
-
在很久以前，演员和剧组都是直接见面联系的。没有中间人环节。
-
而随着时间的推移，产生了一个新兴职业：经纪人（中间人），这个时候剧组再想找演员就需要通过经纪 人来找了。下面我们就用代码演示出来。
/** * 一个经纪公司的要求: * 能做基本的表演和危险的表演 */ public interface IActor { /** * 基本演出 * @param money */ public void basicAct(float money); /** * 危险演出 * @param money */ public void dangerAct(float money); } /** * 一个演员 */ //实现了接口，就表示具有接口中的方法实现。即：符合经纪公司的要求 public class Actor implements IActor{ public void basicAct(float money){ System.out.println("拿到钱，开始基本的表演："+money); } public void dangerAct(float money){ System.out.println("拿到钱，开始危险的表演："+money); } }public class Client { public static void main(String[] args) { //一个剧组找演员： final Actor actor = new Actor();//直接 /** * 代理： * 间接。 * 获取代理对象： * 要求： * 被代理类最少实现一个接口 * 创建的方式 * Proxy.newProxyInstance(三个参数) * 参数含义： * ClassLoader：和被代理对象使用相同的类加载器。 * Interfaces：和被代理对象具有相同的行为。实现相同的接口。 * InvocationHandler：如何代理。 * 策略模式：使用场景是： * 数据有了，目的明确。 * 如何达成目标，就是策略。 * */ IActor proxyActor = (IActor) Proxy.newProxyInstance( actor.getClass().getClassLoader(), actor.getClass().getInterfaces(), new InvocationHandler() { /** * 执行被代理对象的任何方法，都会经过该方法。 * 此方法有拦截的功能。 * * 参数： * proxy：代理对象的引用。不一定每次都用得到 * method：当前执行的方法对象 * args：执行方法所需的参数 * 返回值： * 当前执行方法的返回值 */ @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { String name = method.getName(); Float money = (Float) args[0]; Object rtValue = null; //每个经纪公司对不同演出收费不一样，此处开始判断 if("basicAct".equals(name)){ //基本演出，没有 2000 不演 if(money > 2000){ //看上去剧组是给了 8000，实际到演员手里只有 4000 //这就是我们没有修改原来 basicAct 方法源码，对方法进行了增强 rtValue = method.invoke(actor, money/2); } } if("dangerAct".equals(name)){ //危险演出,没有 5000 不演 if(money > 5000){ //看上去剧组是给了 50000，实际到演员手里只有 25000 //这就是我们没有修改原来 dangerAct 方法源码，对方法进行了增强 rtValue = method.invoke(actor, money/2); } } return rtValue; } }); //没有经纪公司的时候，直接找演员。 // actor.basicAct(1000f); // actor.dangerAct(5000f); //剧组无法直接联系演员，而是由经纪公司找的演员 proxyActor.basicAct(8000f); proxyActor.dangerAct(50000f); } }
-
-
Spring中的AOP
Spring中AOP的细节
AOP相关术语
- Joinpoint(连接点):
- 所谓连接点是指那些被拦截到的点。在 spring 中,这些点指的是方法,因为 spring 只支持方法类型的 连接点。
- Pointcut(切入点):
- 所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义。
- Advice(通知/增强):
- 所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知。
- 通知的类型：前置通知,后置通知,异常通知,最终通知,环绕通知。
- Introduction(引介):
- 引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方 法或 Field。
- Target(目标对象):
- 代理的目标对象。
- Weaving(织入):
- 是指把增强应用到目标对象来创建新的代理对象的过程。 spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装载期织入。
- Proxy（代理）:
- 一个类被 AOP 织入增强后，就产生一个结果代理类。
- Aspect(切面):
- 是切入点和通知（引介）的结合。
学习spring中的AOP要明确的事
- 开发阶段（我们做的）
- 编写核心业务代码（开发主线）：大部分程序员来做，要求熟悉业务需求。
- 把公用代码抽取出来，制作成通知。（开发阶段最后再做）：AOP 编程人员来做。
- 在配置文件中，声明切入点与通知间的关系，即切面。：AOP 编程人员来做。
- 运行阶段（Spring框架完成的）
- Spring 框架监控切入点方法的执行。一旦监控到切入点方法被运行，使用代理机制，动态创建目标对 象的代理对象，根据通知类别，在代理对象的对应位置，将通知对应的功能织入，完成完整的代码逻辑运行。
关于代理的选择
- 在 spring 中，框架会根据目标类是否实现了接口来决定采用哪种动态代理的方式。
基于XML的AOP配置
环境搭建
-
第一步：准备必要的代码 （实体类，业务层和持久层代码。）
-
第二步：拷贝必备的 jar 包到工程的 lib 目录
-
第三步：创建 spring 的配置文件并导入约束
<!--此处要导入 aop 的约束 --> <?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: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/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> </beans> -
第四步：配置 spring 的 ioc
<!-- 配置 service --> <bean id="accountService" class="com.service.impl.AccountServiceImpl"> <property name="accountDao" ref="accountDao"></property> </bean> <!-- 配置 dao --> <bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl"> <property name="dbAssit" ref="dbAssit"></property> </bean> <!-- 配置数据库操作对象 --> <bean id="dbAssit" class="com.itheima.dbassit.DBAssit"> <property name="dataSource" ref="dataSource"></property> <!-- 指定 connection 和线程绑定 --> <property name="useCurrentConnection" value="true"></property> </bean> <!-- 配置数据源 --> <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"> <property name="driverClass" value="com.mysql.jdbc.Driver"></property> <property name="jdbcUrl" value="jdbc:mysql:///spring"></property> <property name="user" value="root"></property> <property name="password" value="root"></property> </bean> -
第五步：抽取公共代码制作成通知
public class TransactionManager { //定义一个 DBAssit private DBAssit dbAssit ; public void setDbAssit(DBAssit dbAssit) { this.dbAssit = dbAssit; } //开启事务 public void beginTransaction() { try { dbAssit.getCurrentConnection().setAutoCommit(false); } catch (SQLException e) { e.printStackTrace(); } } //提交事务 public void commit() { try { dbAssit.getCurrentConnection().commit(); } catch (SQLException e) { e.printStackTrace(); } } //回滚事务 public void rollback() { try { dbAssit.getCurrentConnection().rollback(); } catch (SQLException e) { e.printStackTrace(); } } //释放资源 public void release() { try { dbAssit.releaseConnection(); } catch (Exception e) { e.printStackTrace(); } } }
配置步骤
-
第一步：把通知类用 bean 标签配置起来
<!-- 配置通知 --> <bean id="txManager" class="com.itheima.utils.TransactionManager"> <property name="dbAssit" ref="dbAssit"></property> </bean> -
第二步：使用 aop:config 声明 aop 配置
- aop:config:
作用：用于声明开始 aop 的配置
<aop:config> <!-- 配置的代码都写在此处 --> </aop:config> - aop:config:
-
第三步：使用 aop:aspect 配置切面
- aop:aspect:
作用：
用于配置切面。
属性：
id：给切面提供一个唯一标识。
ref：引用配置好的通知类 bean 的 id。
<aop:aspect id="txAdvice" ref="txManager"> <!--配置通知的类型要写在此处--> </aop:aspect> - aop:aspect:
-
第四步：使用 aop:pointcut 配置切入点表达式
- aop:pointcut：
作用：
用于配置切入点表达式。就是指定对哪些类的哪些方法进行增强。
属性：
expression：用于定义切入点表达式。
id：用于给切入点表达式提供一个唯一标识
<aop:pointcut expression="execution( public void com.itheima.service.impl.AccountServiceImpl.transfer( java.lang.String, java.lang.String, java.lang.Float) )" id="pt1"/> - aop:pointcut：
-
第五步：使用 aop:xxx 配置对应的通知类型
- aop:before
作用：
用于配置前置通知。指定增强的方法在切入点方法之前执行
属性：
method:用于指定通知类中的增强方法名称
ponitcut-ref：用于指定切入点的表达式的引用
poinitcut：用于指定切入点表达式
执行时间点：
切入点方法执行之前执行 - aop:after-returning
作用：
用于配置后置通知
属性：
method：指定通知中方法的名称。
pointct：定义切入点表达式
pointcut-ref：指定切入点表达式的引用
执行时间点：
切入点方法正常执行之后。它和异常通知只能有一个执行 - aop:after-throwing
作用：
用于配置异常通知
属性：
method：指定通知中方法的名称。
pointct：定义切入点表达式
pointcut-ref：指定切入点表达式的引用
执行时间点：
切入点方法执行产生异常后执行。它和后置通知只能执行一个 - aop:after
作用：
用于配置最终通知
属性：
method：指定通知中方法的名称。
pointct：定义切入点表达式
pointcut-ref：指定切入点表达式的引用
执行时间点：
无论切入点方法执行时是否有异常，它都会在其后面执行。
<aop:before method="beginTransaction" pointcut-ref="pt1"/> <aop:after-returning method="commit" pointcut-ref="pt1"/> <aop:after-throwing method="rollback" pointcut-ref="pt1"/> <aop:after method="release" pointcut-ref="pt1"/> - aop:before
基于注解的AOP配置
环境搭建
-
第一步：准备必要的代码和 jar包
-
第二步：在配置文件中导入 context 的名称空间
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> <!-- 配置数据库操作对象 --> <bean id="dbAssit" class="com.dbassit.DBAssit"> <property name="dataSource" ref="dataSource"></property> <!-- 指定 connection 和线程绑定 --> <property name="useCurrentConnection" value="true"></property> </bean> <!-- 配置数据源 --> <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"> <property name="driverClass" value="com.mysql.jdbc.Driver"></property> <property name="jdbcUrl" value="jdbc:mysql:///spring_day02"></property> <property name="user" value="root"></property> <property name="password" value="1234"></property> </bean> </beans> -
第三步：把资源使用注解配置
//账户的业务层实现类 @Service("accountService") public class AccountServiceImpl implements IAccountService { @Autowired private IAccountDao accountDao; } //账户的持久层实现类 @Repository("accountDao") public class AccountDaoImpl implements IAccountDao { @Autowired private DBAssit dbAssit ; } -
第四步：在配置文件中指定 spring 要扫描的包
<!-- 告知 spring，在创建容器时要扫描的包 --> <context:component-scan base-package="com.seafy"></context:component-scan>
配置步骤
-
第一步：把通知类也使用注解配置
//事务控制类 @Component("txManager") public class TransactionManager { //定义一个 DBAssit @Autowired private DBAssit dbAssit ; } -
第二步：在通知类上使用@Aspect 注解声明为切面
-
作用：把当前类声明为切面类
@Aspect//表明当前类是一个切面类 public class TransactionManager { //定义一个 DBAssit @Autowired private DBAssit dbAssit ; }
-
-
第三步：在增强的方法上使用注解配置通知
- @Before
作用：
把当前方法看成是前置通知。
属性：
value：用于指定切入点表达式，还可以指定切入点表达式的引用。 - @AfterReturning
作用：
把当前方法看成是后置通知。
属性：
value：用于指定切入点表达式，还可以指定切入点表达式的引用 - @AfterThrowing
作用：
把当前方法看成是异常通知。
属性：
value：用于指定切入点表达式，还可以指定切入点表达式的引用 - @After
作用：
把当前方法看成是最终通知。
属性：
value：用于指定切入点表达式，还可以指定切入点表达式的引用
//开启事务 @Before("execution(* com.itheima.service.impl.*.*(..))") public void beginTransaction() { try { dbAssit.getCurrentConnection().setAutoCommit(false); } catch (SQLException e) { e.printStackTrace(); } } //提交事务 @AfterReturning("execution(* com.itheima.service.impl.*.*(..))") public void commit() { try { dbAssit.getCurrentConnection().commit(); } catch (SQLException e) { e.printStackTrace(); } } //回滚事务 @AfterThrowing("execution(* com.itheima.service.impl.*.*(..))") public void rollback() { try { dbAssit.getCurrentConnection().rollback(); } catch (SQLException e) { e.printStackTrace(); } } //释放资源 @After("execution(* com.itheima.service.impl.*.*(..))") public void release() { try { dbAssit.releaseConnection(); } catch (Exception e) { e.printStackTrace(); } } - @Before
-
第四步：在 spring 配置文件中开启 spring 对注解 AOP 的支持
<!-- 开启 spring 对注解 AOP 的支持 --> <aop:aspectj-autoproxy/>
Spring中的JdbcTemplate
JdbcTemplate概述
- 它是 spring 框架中提供的一个对象，是对原始 Jdbc API 对象的简单封装。spring 框架为我们提供了很多 的操作模板类。
- 操作关系型数据的：
- JdbcTemplate
- HibernateTemplate
- 操作 nosql 数据库的：
- RedisTemplate
- 操作消息队列的：
- JmsTemplate
JdbcTemplate对象的创建
public JdbcTemplate() {
}
public JdbcTemplate(DataSource dataSource) {
setDataSource(dataSource);
afterPropertiesSet();
}
public JdbcTemplate(DataSource dataSource, boolean lazyInit) {
setDataSource(dataSource);
setLazyInit(lazyInit);
afterPropertiesSet();
}
JdbcTemplate的增删改查操作
-
在 spring 配置文件中配置 JdbcTemplate
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> <!-- 配置一个数据库的操作模板：JdbcTemplate --> <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> <property name="dataSource" ref="dataSource"></property> </bean> <!-- 配置数据源 --> <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"> <property name="driverClassName" value="com.mysql.jdbc.Driver"></property> <property name="url" value="jdbc:mysql:///spring_day02"></property> <property name="username" value="root"></property> <property name="password" value="1234"></property> </bean> </beans> -
最基本使用
public class JdbcTemplateDemo2 { public static void main(String[] args) { //1.获取 Spring 容器 ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml"); //2.根据 id 获取 bean 对象 JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate"); //3.执行操作 jt.execute("insert into account(name,money)values('eee',500)"); } } -
保存操作
public class JdbcTemplateDemo3 { public static void main(String[] args) { //1.获取 Spring 容器 ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml"); //2.根据 id 获取 bean 对象 JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate"); //3.执行操作 //保存 jt.update("insert into account(name,money)values(?,?)","fff",5000); } } -
更新操作
public class JdbcTemplateDemo3 { public static void main(String[] args) { //1.获取 Spring 容器 ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml"); //2.根据 id 获取 bean 对象 JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate"); //3.执行操作 //修改 jt.update("update account set money = money-? where id = ?",300,6); } } -
删除操作
public class JdbcTemplateDemo3 { public static void main(String[] args) { //1.获取 Spring 容器 ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml"); //2.根据 id 获取 bean 对象 JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate"); //3.执行操作 //删除 jt.update("delete from account where id = ?",6); } } -
查询所有操作
public class JdbcTemplateDemo3 { public static void main(String[] args) { //1.获取 Spring 容器 ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml"); //2.根据 id 获取 bean 对象 JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate"); //3.执行操作 //查询所有 List<Account> accounts = jt.query("select * from account where money > ? ", new AccountRowMapper(), 500); for(Account o : accounts){ System.out.println(o); } } } public class AccountRowMapper implements RowMapper<Account>{ @Override public Account mapRow(ResultSet rs, int rowNum) throws SQLException { Account account = new Account(); account.setId(rs.getInt("id")); account.setName(rs.getString("name")); account.setMoney(rs.getFloat("money")); return account; } -
查询一个操作
//使用 RowMapper 的方式：常用的方式 public class JdbcTemplateDemo3 { public static void main(String[] args) { //1.获取 Spring 容器 ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml"); //2.根据 id 获取 bean 对象 JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate"); //3.执行操作 //查询一个 List<Account> as = jt.query("select * from account where id = ? ", new AccountRowMapper(), 55); System.out.println(as.isEmpty()?"没有结果":as.get(0)); } } //使用 ResultSetExtractor 的方式:不常用的方式 public class JdbcTemplateDemo3 { public static void main(String[] args) { //1.获取 Spring 容器 ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml"); //2.根据 id 获取 bean 对象 JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate"); //3.执行操作 //查询一个 Account account = jt.query("select * from account where id = ?", new AccountResultSetExtractor(),3); System.out.println(account); } } -
查询返回一行一列操作
public class JdbcTemplateDemo3 { public static void main(String[] args) { //1.获取 Spring 容器 ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml"); //2.根据 id 获取 bean 对象 JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate"); //3.执行操作 //查询返回一行一列：使用聚合函数，在不使用 group by 字句时，都是返回一行一列。最长用的 就是分页中获取总记录条数 Integer total = jt.queryForObject("select count(*) from account where money > ? ",Integer.class,500); System.out.println(total); } }
Spring中的事务控制
Spring中事务控制的API介绍
- PlatformTransactionManager
- 此接口是 spring 的事务管理器，它里面提供了我们常用的操作事务的方法
- 获取事务状态信息
- TransactionStatus getTransaction(TransactionDefinition definition)
- 提交事务
- void commit(TransactionStatus status)
- 回滚事务
- void rollback(TransactionStatus status)
- 获取事务状态信息
- 此接口是 spring 的事务管理器，它里面提供了我们常用的操作事务的方法
- TransactionDefinition
- 它是事务的定义信息对象
- 获取事务对象名称
- String getName()
- 获取事务隔离级
- int getlsolationLevel()
- 获取事务传播行为
- int getPropagationBehavior()
- 获取事务超时时间
- int getTimeout()
- 获取事务是否只读
- boolean isReadOnly()
- 获取事务对象名称
- 它是事务的定义信息对象
- TransactionStatus
- 此接口提供的是事务具体的运行状态
- TransactionStatus接口描述了摸个时间点上事务对象的状态信息，包含6个具体操作
- 刷新事务
- void flush()
- 获取是否存在存储点
- boolean hasSavepoint()
- 获取事务是否完成
- boolean isCompleted()
- 获取事务是否为新的事务
- boolean isNewTransaction()
- 获取事务是否回滚
- boolean isRollbackOnly()
- 获取事务回滚
- void setRollbackOnly()
- 刷新事务
基于XML的声明式事务控制
环境搭建
- 第一步：拷贝必要的 jar 包到工程的 lib 目录
- 第二步：创建 spring 的配置文件并导入约束
- 第三步：准备数据库表和实体类
- 第四步：编写业务层接口和实现类
- 第五步：编写 Dao 接口和实现类
- 第六步：在配置文件中配置业务层和持久层对
配置步骤
- 第一步：配置事务管理器
- 第二步：配置事务的通知引用事务管理器
- 第三步：配置事务的属性
- 第四步：配置 AOP 切入点表达式
- 第五步：配置切入点表达式和事务通知的对应关系
基于注解的配置方式
环境搭建
-
第一步：拷贝必备的 jar 包到工程的 lib 目录
-
第二步：创建 spring 的配置文件导入约束并配置扫描的包
-
第三步：创建数据库表和实体类
-
第四步：创建业务层接口和实现类并使用注解让 spring 管理
/** * 账户的业务层实现类 */ @Service("accountService") public class AccountServiceImpl implements IAccountService { @Autowired private IAccountDao accountDao; //其余代码和基于 XML 的配置相同 } -
第五步：创建 Dao 接口和实现类并使用注解让 spring 管理
/** * 账户的持久层实现类 */ @Repository("accountDao") public class AccountDaoImpl implements IAccountDao { @Autowired private JdbcTemplate jdbcTemplate; //其余代码和基于 XML 的配置相同 }
配置步骤
-
第一步：配置事务管理器并注入数据源
<!-- 配置事务管理器 --> <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="dataSource" ref="dataSource"></property> </bean> -
第二步：在业务层使用@Transactional 注解
@Service("accountService") @Transactional(readOnly=true,propagation=Propagation.SUPPORTS) public class AccountServiceImpl implements IAccountService { @Autowired private IAccountDao accountDao; @Override public Account findAccountById(Integer id) { return accountDao.findAccountById(id); } @Override @Transactional(readOnly=false,propagation=Propagation.REQUIRED) public void transfer(String sourceName, String targeName, Float money) { //1.根据名称查询两个账户 Account source = accountDao.findAccountByName(sourceName); Account target = accountDao.findAccountByName(targeName); //2.修改两个账户的金额 source.setMoney(source.getMoney()-money);//转出账户减钱 target.setMoney(target.getMoney()+money);//转入账户加钱 //3.更新两个账户 accountDao.updateAccount(source); //int i=1/0; accountDao.updateAccount(target); } } -
第三步：在配置文件中开启 spring 对注解事务的支持
<!-- 开启 spring 对注解事务的支持 --> <tx:annotation-driven transaction-manager="transactionManager"/>
扫一扫
2030
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
