Sring第六课-------spring(AOP注解开发、JdbcTemplate使用、spring事务管理)

本文链接：https://blog.csdn.net/weixin_51311218/article/details/115569140

Spring

一、课程目标

【掌握】SpringAOP注解开发
【理解】JdbcTemplate的使用
【理解】SpringTX事务操作

二、AOP注解开发

2.1 快速使用

①创建核心配置文件配置spring开启注解扫描

<?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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- 开启注解扫描 -->
    <context:component-scan base-package="com.yunhe"/>

    
</beans>

②创建目标接口和目标类使用注解交由spring管理（内部有切点）

public interface BankService {
    //存款
    boolean saveMoney(int id, double money);
    //取款
    boolean drawMoney(int id, double money);
    //转账
    boolean turnMoney(int sid,int did, double money);
}

@Service
public class BankServiceImpl implements BankService {
    @Override
    public boolean saveMoney(int id, double money) {
        System.out.println("为id为"+id+"的账号存入金额:"+money);
        return true;
    }
    @Override
    public boolean drawMoney(int id, double money) {
        System.out.println("从id为"+id+"的账号取出金额:"+money);
        return true;
    }
    @Override
    public boolean turnMoney(int sid, int did, double money) {
        System.out.println("为id为"+sid+"的账号存入金额:"+money);
        System.out.println("从id为"+did+"的账号取出金额:"+money);
        return true;
    }
}

③创建切面类书写切面方法并使用注解交由spring管理

@Component
public class MoneyAspect {

    //前置通知
    public void before() {
        System.out.println("原方法执行前增强的方法");
    }

    //后置通知
    public void after() {
        System.out.println("原方法执行后增强的方法");
    }

    //环绕通知
    //joinPoint获取执行方法参数等参数
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("环绕通知");
        Object[] args = joinPoint.getArgs();//获取请求参数
        Object proceed = joinPoint.proceed(args);//调用源方法
        System.out.println("环绕通知");
        return proceed;
    }

    //异常通知
    public void exception (Exception e) {
        System.out.println(e);
    }

    //返回通知
    public void returning (JoinPoint joinPoint, Object o) throws Throwable {
        System.out.println(Arrays.toString(joinPoint.getArgs()));
        System.out.println(o);
    }

}

④在配置文件中开启 AOP 的自动代理

    <!-- aop自动代理 -->
    <!-- 默认使用jdk动态代理如果代理类没有接口则使用cglib代理 -->
    <!-- <aop:aspectj-autoproxy/>-->
    <!-- 如果想强制直接使用cglib代理可以通过配置 -->
    <aop:aspectj-autoproxy proxy-target-class="true"/>

⑤在切面类中使用指定的注解进行标识

@Component
@Aspect//标识当前类为切面类
public class MoneyAspect {



    //前置通知
    @Before("execution(* com.yunhe.service.impl.BankServiceImpl.*Money(..))")
    public void before() {
        System.out.println("原方法执行前增强的方法");
    }

    //后置通知
    @After("execution(* com.yunhe.service.impl.BankServiceImpl.*Money(..))")
    public void after() {
        System.out.println("原方法执行后增强的方法");
    }

    //环绕通知
    //joinPoint获取执行方法参数等参数
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("环绕通知");
        Object[] args = joinPoint.getArgs();//获取请求参数
        Object proceed = joinPoint.proceed(args);//调用源方法
        System.out.println("环绕通知");
        return proceed;
    }

    //异常通知
    public void exception (Exception e) {
        System.out.println(e);
    }

    //返回通知
    public void returning (JoinPoint joinPoint, Object o) throws Throwable {
        System.out.println(Arrays.toString(joinPoint.getArgs()));
        System.out.println(o);
    }

}

2.2 注解详情

2.2.1 切面类注解

@Aspect

用于标识当前类为切面类等价于spring核心配置文件中书写在aop：config标签中的aop:aspect标签

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Z9Qs9IAQ-1618026272099)(day0409.assets/image-20210409093415838.png)]

注意：需要与@Component标签一起使用标识切面类

2.2.2 通知注解

通用语法:

@通知类型(value="execution(切点表达式)")

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UoCQ0ZXL-1618026272101)(day0409.assets/image-20210409093528624.png)]

Before注解

前置通知通过切点表达式对指定方法进行前置增强，在方法执行前增强

//前置通知
@Before("execution(* com.yunhe.service.impl.BankServiceImpl.*Money(..))")
public void before() {
    System.out.println("原方法执行前增强的方法");
}

等价于xml配置

<aop:before method="before"  pointcut="execution(* com.yunhe.service.impl.BankServiceImpl.*Money(..))"></aop:before>

After注解

后置通知也叫最终通知，通过切点表达式对指定方法进行后置增强，在方法执行后增强（无论方法是否执行成功）

//后置通知
@After("execution(* com.yunhe.service.impl.BankServiceImpl.*Money(..))")
public void after() {
    System.out.println("原方法执行后增强的方法");
}

等价于xml配置

<aop:after method="after"  pointcut="execution(* com.yunhe.service.impl.BankServiceImpl.*Money(..))"></aop:after>

Around注解

环绕通知，通过切点表达式对指定方法进行环绕增强，在方法执行前后进行增强（需要在增强方法中进行原方法的调用否则可能导致方法不能正常执行）

//环绕通知
@Around("execution(* com.yunhe.service.impl.BankServiceImpl.*Money(..))")
public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
    System.out.println("环绕通知");
    Object[] args = joinPoint.getArgs();//获取请求参数
    Object proceed = joinPoint.proceed(args);//调用源方法
    System.out.println("环绕通知");
    // ProceedingJoinPoint 环绕通知中使用的获取原方法的参数
    //getArgs()获取原方法请求执行时传入的参数
    //proceed(args)调用执行原方法传入参数
    return proceed;
}

等价于xml配置

<aop:around method="around"  pointcut="execution(* com.yunhe.service.impl.BankServiceImpl.*Money(..))"></aop:around>

AfterThrowing注解

异常通知，通过切点表达式对指定方法进行异常增强，通常用于进行异常的提示

    //异常通知
    @AfterThrowing(value = "execution(* com.yunhe.service.impl.BankServiceImpl.*Money(..))", throwing = "e")
    public void exception(Exception e) {
        System.out.println(e);
    }

等价于xml配置

<aop:after-throwing method="exception" throwing="e" pointcut="execution(* com.yunhe.service.impl.BankServiceImpl.*Money(..))"></aop:after-throwing>

Afterreturning注解

返回通知，通过切点表达式对指定方法进行增强,在方法执行结束返回结果后执行，但是如果方法执行发生异常则不会执行

    //返回通知
    @AfterReturning(value = "execution(* com.yunhe.service.impl.BankServiceImpl.*Money(..))",returning = "o")
    public void returning(JoinPoint joinPoint, Object o) throws Throwable {
        System.out.println(Arrays.toString(joinPoint.getArgs()));
        System.out.println(o);
    }

等价于xml配置

<aop:after-returning method="returning"  returning="o" pointcut="execution(* com.yunhe.service.impl.BankServiceImpl.*Money(..))"></aop:after-returning>

2.2.3 通用切点表达式

Pointcut注解

当多个切点使用相同切点表达式时可以创建方法使用Pointcut注解书写切点表达式，其他通知方法通过类名.方法名获取切点

@Pointcut("execution(* com.yunhe.service.impl.BankServiceImpl.*Money(..))")
//书写方法使用注解定义通用切点表达式
public void pointcut(){}

//前置通知
//  @Before("execution(* com.yunhe.service.impl.BankServiceImpl.*Money(..))")
@Before("MoneyAspect.pointcut()")
//使用类名.配置切点表达式方法名进行获取
public void before() {
    System.out.println("原方法执行前增强的方法");
}

在实际开发过程中通常会创建一个单独保存切点表达式的切面类，其他切面类通过类名.方法名使用对应切点，当然也可以为不同功能aop创建不用的切面类将对应功能的切点表达式书写在对应功能的切面类中

三、JdbcTemplate的使用

3.1 概念

JdbcTemplate是spring框架中提供的一个对象，是对原始繁琐的Jdbc API对象的简单封装。spring框架为我们提供了很多的操作模板类。例如：操作关系型数据的JdbcTemplate和HibernateTemplate，操作nosql数据库的RedisTemplate，操作消息队列的JmsTemplate等等。

3.2 快速使用

①导入相应jar包坐标

    <!-- spring进行jdbc操作的依赖 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>5.1.2.RELEASE</version>
    </dependency>
    <!-- spring进行事务管理的依赖 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>5.0.5.RELEASE</version>
    </dependency>
    <!-- 连接mysql数据库的依赖 -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.32</version>
    </dependency>
    <!-- 数据源C3P0管理依赖 -->
    <dependency>
      <groupId>c3p0</groupId>
      <artifactId>c3p0</artifactId>
      <version>0.9.1.2</version>
    </dependency>
    <!-- 数据源DRUID管理依赖 -->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.10</version>
    </dependency>
    <!-- 单元测试依赖 -->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
    </dependency>
    <!-- spring核心依赖 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.0.5.RELEASE</version>
    </dependency>
    <!-- spring进行测试依赖 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>5.0.5.RELEASE</version>
    </dependency>
    <!-- spring进行web开发依赖 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>5.0.5.RELEASE</version>
    </dependency>
    <!-- springMVC核心依赖 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.0.5.RELEASE</version>
    </dependency>
    <!-- servlet依赖 -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.0.1</version>
      <scope>provided</scope>
    </dependency>
    <!-- jsp依赖 -->
    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>javax.servlet.jsp-api</artifactId>
      <version>2.2.1</version>
      <scope>provided</scope>
    </dependency>
    <!-- json转化依赖 -->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-core</artifactId>
      <version>2.9.0</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.9.0</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-annotations</artifactId>
      <version>2.9.0</version>
    </dependency>
    <!-- spring进行aop 织入依赖 -->
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.8.13</version>
    </dependency>
    <!-- 文件上传依赖 -->
    <dependency>
      <groupId>commons-fileupload</groupId>
      <artifactId>commons-fileupload</artifactId>
      <version>1.3.1</version>
    </dependency>
    <dependency>
      <groupId>commons-io</groupId>
      <artifactId>commons-io</artifactId>
      <version>2.3</version>
    </dependency>
  </dependencies>

②创建数据库表和实体类

建表语句

CREATE TABLE `user` (
  `uid` int(255) NOT NULL AUTO_INCREMENT,
  `uname` varchar(255) DEFAULT NULL,
  `umoney` double(255,2) NOT NULL DEFAULT '0.00',
  PRIMARY KEY (`uid`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

实体类

public class User implements Serializable {
    private int uid;
    private String uname;
    private double umoney;
//构造 getter setter toSting方法 
}

③创建JdbcTemplate对象

		//创建数据源对象
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setDriverClass("com.mysql.jdbc.Driver");
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test");
        dataSource.setUser("root");
        dataSource.setPassword("root");
		
		//创建JdbcTemplate对象 
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        //设置数据源对象  知道数据库在哪
        jdbcTemplate.setDataSource(dataSource);

④使用jdbcTemplate对象执行数据库操作

更新操作

        int i = jdbcTemplate.update("insert into user (uname,umoney) values(?,?);", "李四", 200);
        System.out.println(i);

查询操作

        //由于没有提供自动映射 所以spring不能管理数据库数据列与实体类之间的关系 所以需要实现rowMapper接口进行书写
        List<User> query = jdbcTemplate.query("select * from user", new RowMapper<User>() {
            @Override
            public User mapRow(ResultSet resultSet, int i) throws SQLException {
                User user=new User();
                user.setUid(resultSet.getInt("uid"));
                user.setUname(resultSet.getString("uname"));
                user.setUmoney(resultSet.getDouble("umoney"));
                return user;
            }
        });
        System.out.println(query);

3.3 使用spring进行JdbcTemplate的管理

①书写数据源配置文件

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/sms
jdbc.username=root
jdbc.password=root

②将数据源与JdbcTemplate交由spring管理配置文件

    <!-- 加载数据源配置文件db.properties -->
    <context:property-placeholder location="classpath:db.properties"/>
        
    <!-- 配置数据源读取配置文件进行依赖注入 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
    
    <!-- 配置jdbcTemplate 将使用的数据源注入 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>

③加载核心配置文件获取指定对象执行方法

ApplicationContext applicationContext=new ClassPathXmlApplicationContext("spring.xml");
JdbcTemplate jdbcTemplate = (JdbcTemplate) applicationContext.getBean("jdbcTemplate");

//由于没有提供自动映射 所以spring不能管理数据库数据列与实体类之间的关系 所以需要实现rowMapper接口进行书写
List<User> query = jdbcTemplate.query("select * from user", new RowMapper<User>() {
    @Override
    public User mapRow(ResultSet resultSet, int i) throws SQLException {
        User user=new User();
        user.setUid(resultSet.getInt("uid"));
        user.setUname(resultSet.getString("uname"));
        user.setUmoney(resultSet.getDouble("umoney"));
        return user;
    }
});

//使用自动映射（要求列与实体类必须类型名称匹配）
 List<User> query = jdbcTemplate.query("select * from user",new BeanPropertyRowMapper<User>(User.class));
        System.out.println(query);
System.out.println(query);

四、spring事务控制

4.1 概念

事务一般是由数据源进行自动配置，声明式事务也叫编程式事务，是spring提供用于在代码编写时自动进行事务管理的对象，依赖于springAOP，可以理解为是AOP的另一种用法，内部自动的切了数据库所有的操作

4.2 PlatformTransactionManager平台事务管理器接口

用于声明各种事务管理的方法的总接口，根据使用的平台不同拥有不同的实现类

PlatformTransactionManager 是接口类型，不同的 Dao 层技术则有不同的实现类，例如：
Dao 层技术是jdbc 或 mybatis 时：org.springframework.jdbc.datasource.DataSourceTransactionManager
Dao 层技术是hibernate时：org.springframework.orm.hibernate5.HibernateTransactionManager

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Jx1foWaC-1618026272103)(day0409.assets/image-20210409145359601.png)]

4.3 TransactionDefinition事务的定义信息对象

TransactionDefinition 是事务的定义信息对象
事务的定义包括: 事务的隔离级别，事务的传播属性，超时时间设置，是否只读
事务的隔离级别是数据库本身的事务功能，事务的传播属性则是spring为我们提供的功能
该接口的实现DefaultTransactionDefinition,默认的事务定义

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vvBwIIVj-1618026272105)(day0409.assets/image-20210409145545937.png)]

事务的隔离级别

当一个事务对数据处理时其他事务对该数据的处理方式

ISOLATION_DEFAULT 默认跟随数据库
ISOLATION_READ_UNCOMMITTED 读未提交
ISOLATION_READ_COMMITTED 读已提交
ISOLATION_REPEATABLE_READ 可重复读
ISOLATION_SERIALIZABLE 串行化

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-B4oSq2pv-1618026272106)(day0409.assets/image-20210409145734113.png)]

事务的传播行为

当前操作中多个执行是否使用同一个事务进行事务的处理

REQUIRED：如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。一般的选择（默认值）
SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行（没有事务）
MANDATORY：使用当前的事务，如果当前没有事务，就抛出异常
REQUERS_NEW：新建事务，如果当前在事务中，把当前事务挂起。
NOT_SUPPORTED：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起
NEVER：以非事务方式运行，如果当前存在事务，抛出异常
NESTED：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行 REQUIRED 类似的操作
超时时间：默认值是-1，没有超时限制。如果有，以秒为单位进行设置
是否只读：建议查询时设置为只读

4.4 TransactionStatus 事务状态接口

TransactionStatus 接口提供的是事务具体的运行状态
TransactionStatus它继承了SavepointManager接口，SavepointManager是对事务中上述保存点功能的封装

public interface SavepointManager {
    Object createSavepoint() throws TransactionException;
    void rollbackToSavepoint(Object savepoint) throws TransactionException;
    void releaseSavepoint(Object savepoint) throws TransactionException;
}

TransactionStatus本身更多存储的是事务的一些状态信息

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GYDOjyrq-1618026272107)(day0409.assets/image-20210409150620078.png)]

4.5 基于xml配置的spring事务管理

声明式事务处理的作用

事务管理不侵入开发的组件。具体来说，业务逻辑对象就不会意识到正在事务管理之中，事实上也应该如此，因为事务管理是属于系统层面的服务，而不是业务逻辑的一部分，如果想要改变事务管理策划的话，也只需要在定义文件中重新配置即可

在不需要事务管理的时候，只要在设定文件上修改一下，即可移去事务管理服务，无需改变代码重新编译，这样维护起来极其方便

注意：Spring 声明式事务控制底层就是AOP。

①引入tx命名空间

<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:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx 
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">
    
</beans>

②配置平台事务管理器以及事务增强

<!--平台事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"></property>
</bean>

<!--事务增强配置-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
        <tx:method name="*"/>
    </tx:attributes>
</tx:advice>

③配置事务AOP 织入

通过切点表达式配置事务管理的方法

    <!--事务的aop增强-->
    <aop:config>
        <aop:pointcut id="myPointcut" expression="execution(* com.yunhe.service.impl.*.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="myPointcut"></aop:advisor>
    </aop:config>

④测试事务控制业务代码

当出现异常时会自动回滚事务

        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("spring.xml");
        BankServiceImpl bean = applicationContext.getBean(BankServiceImpl.class);
        bean.turnMoney(2,1,200);

事务增强配置

 <tx:method name="*"/>

默认使用的是默认配置* 代表所有数据库操作增强

<tx:method name="turnMoney" isolation="REPEATABLE_READ" propagation="REQUIRED" timeout="-1" read-only="false"/>

可以为切点表达式匹配的指定方法进行增强设置

name：切点方法名称
isolation:事务的隔离级别
propogation：事务的传播行为
timeout：超时时间
read-only：是否只读

4.6 基于注解配置的spring事务管理

①引入tx命名空间

<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:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx 
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">
    
</beans>

②配置相应的类交由spring管理

    <!-- 加载数据源配置文件db.properties -->
    <context:property-placeholder location="classpath:db.properties"/>

    <!-- 配置数据源读取配置文件进行依赖注入 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

	<!-- 配置jdbcTemplate 将使用的数据源注入 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!--平台事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

③加入相应的组件配置

    <!-- 开启组件扫描 -->
    <context:component-scan base-package="com.yunhe"/>

    <!-- 开启aop自动代理 -->
    <aop:aspectj-autoproxy/>
    
    <!-- 开启事务注解驱动 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>

④书写相应的事务管理接口与方法

public interface BankService {
    //存款
    boolean saveMoney(int id, double money);
    //取款
    boolean drawMoney(int id, double money);
    //转账
    boolean turnMoney(int sid,int did, double money);
}

@Service
public class BankServiceImpl implements BankService {

    @Resource
    JdbcTemplate jdbcTemplate;
    
    @Override
    public boolean saveMoney(int id, double money) {
        int update = jdbcTemplate.update("update user set umoney=umoney+? where uid =?", money, id);
        if(update!=1){
            return false;
        }
        return true;
    }

    @Override
    public boolean drawMoney(int id, double money) {
        int update = jdbcTemplate.update("update user set umoney=umoney-? where uid =?", money, id);
        if(update!=1){
            return false;
        }
        return true;
    }

    @Override
    public boolean turnMoney(int sid, int did, double money) {
        int s = jdbcTemplate.update("update user set umoney=umoney+? where uid =?", money, sid);
        System.out.println(1/0);
        int d = jdbcTemplate.update("update user set umoney=umoney-? where uid =?", money, did);
        if(s!=1||d!=1){
            return false;
        }
        return true;
    }
}

⑤使用事务注解对需要事务管理的方法修饰

    @Override
    @Transactional(timeout = -1,propagation = Propagation.REQUIRED,isolation = Isolation.DEFAULT)
    public boolean turnMoney(int sid, int did, double money) {
        int s = jdbcTemplate.update("update user set umoney=umoney+? where uid =?", money, sid);
        System.out.println(1/0);
        int d = jdbcTemplate.update("update user set umoney=umoney-? where uid =?", money, did);
        if(s!=1||d!=1){
            return false;
        }
        return true;
    }