知新_RL

这个屌丝很懒，什么也没留下！

热门标签

Spring简介与使用04-事务配置及注解_spring事务的坐标

作者：知新_RL | 2024-05-16 03:58:32

踩

spring事务的坐标

一、JdbcTemplate基本使用

1.1 概述

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

1.2 JdbcTemplate基本使用

①导入jdbc Template相应坐标

   <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>5.0.5.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>5.0.5.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.32</version>
    </dependency>
    <dependency>
      <groupId>c3p0</groupId>
      <artifactId>c3p0</artifactId>
      <version>0.9.1.2</version>
    </dependency>
    <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>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.0.5.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>5.0.5.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>5.0.5.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.0.5.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.0.1</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>javax.servlet.jsp-api</artifactId>
      <version>2.2.1</version>
      <scope>provided</scope>
    </dependency>
    <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>
    <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>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

②创建表与相应的实体类

CREATE TABLE `account` (
  `name` varchar(255) DEFAULT NULL,
  `money` double(255,2) DEFAULT NULL
)
1
2
3
4

public class Account {
    private String name;
    private double money;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public double getMoney() {
        return money;
    }
    public void setMoney(double money) {
        this.money = money;
    }
    @Override
    public String toString() {
        return "Account{" +
                "name='" + name + '\'' +
                ", money=" + money +
                '}';
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

③创建dataSource与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 jt = new JdbcTemplate();
        jt.setDataSource(dataSource);
1
2
3
4
5
6
7
8
9
10

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

        //执行操作
        //  int row = jt.update("insert into account(name) values(?)", "lisi");
        jt.update("delete from account where name=?", "lisi");
1
2
3

1.3 使用spring对dataSource与jdbcTemplate对象进行管理与注入

①创建spring配置文件

<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 http://www.springframework.org/schema/context/spring-context.xsd
">
1
2
3
4
5
6
7

②创建数据库加载properties配置文件

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test
jdbc.username=root
jdbc.password=root
1
2
3
4

③将dataSource与jdbcTemplate交由spring容器管理

 <!--加载jdbc.properties-->
    <context:property-placeholder location="classpath:jdbc.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>
    <!--jdbc模板对象-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>
1
2
3
4
5
6
7
8
9
10
11
12
13

④加载spring配置文件获取相应对象

    ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
    JdbcTemplate jdbcTemplate = (JdbcTemplate) ac.getBean("jdbcTemplate");
1
2

1.4、jdbcTemplate常用方法

public class JdbcTemplateCRUDTest {
	AbstractApplicationContext ac=new ClassPathXmlApplicationContext("spring.xml");;
    JdbcTemplate jdbcTemplate=(JdbcTemplate)ac.getBean("jdbcTemplate");
	//新增
 	@Test
    public void testDelete(){
        jdbcTemplate.update("insert into account values (?,?)","zhagnsan","5000");
    }
	//删除
    @Test
    public void testDelete(){
        jdbcTemplate.update("delete from account where name=?","zhangsan");
    }
	//修改更新
    @Test
    public void testUpdate(){
        jdbcTemplate.update("update account set money=? where name=?",10000,"zhangsan");
    }
    //聚合查询
    @Test
    public void testQueryCount(){
        Long count = jdbcTemplate.queryForObject("select count(*) from account", Long.class);
        System.out.println(count);
    }
	//查询一个
    @Test
    public void testQueryOne(){
        Account account = jdbcTemplate.queryForObject("select * from account where name=?", new BeanPropertyRowMapper<Account>(Account.class), "zhangsan");
        System.out.println(account);
    }
	//查询所有
    @Test
    public void testQueryAll(){
        List<Account> accountList = jdbcTemplate.query("select * from account", new BeanPropertyRowMapper<Account>(Account.class));
        System.out.println(accountList);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

二、声明式事务控制

2.1. 编程式事务控制相关对象

2.1.1 PlatformTransactionManager

PlatformTransactionManager 接口是 spring 的事务管理器，它里面提供了我们常用的操作事务的方法。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0rPTyY74-1601102086455)(img/2020092319063752.png)]
注意：
PlatformTransactionManager 是接口类型，不同的 Dao 层技术则有不同的实现类，例如：
Dao 层技术是jdbc 或 mybatis 时：org.springframework.jdbc.datasource.DataSourceTransactionManager
Dao 层技术是hibernate时：org.springframework.orm.hibernate5.HibernateTransactionManager

2.1.2 TransactionDefinition

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

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

1. 事务隔离级别

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7k9pggBz-1601102086460)(img/20200923190746293.png)]

设置隔离级别，可以解决事务并发产生的问题，如脏读、不可重复读和虚读。

ISOLATION_DEFAULT
ISOLATION_READ_UNCOMMITTED
ISOLATION_READ_COMMITTED
ISOLATION_REPEATABLE_READ
ISOLATION_SERIALIZABLE

2. 事务传播行为

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

2.1.3 TransactionStatus

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

public interface SavepointManager {
    Object createSavepoint() throws TransactionException;
    void rollbackToSavepoint(Object savepoint) throws TransactionException;
    void releaseSavepoint(Object savepoint) throws TransactionException;
}
12345
1
2
3
4
5
6

三、使用xml配置进行spring事务管理

3.1 什么是声明式事务控制

Spring 的声明式事务顾名思义就是采用声明的方式来处理事务。这里所说的声明，就是指在配置文件中声明，用在 Spring 配置文件中声明式的处理事务来代替代码式的处理事务。

声明式事务处理的作用

事务管理不侵入开发的组件。具体来说，业务逻辑对象就不会意识到正在事务管理之中，事实上也应该如此，因为事务管理是属于系统层面的服务，而不是业务逻辑的一部分，如果想要改变事务管理策划的话，也只需要在定义文件中重新配置即可
在不需要事务管理的时候，只要在设定文件上修改一下，即可移去事务管理服务，无需改变代码重新编译，这样维护起来极其方便

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

3.2 声明式事务控制的实现

声明式事务控制明确事项：

谁是切点？
谁是通知？
配置切面？

3.3 使用xml配置形式进行事务控制

①导入事务控制相应的坐标

<dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>5.0.5.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>5.0.5.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.32</version>
    </dependency>
    <dependency>
      <groupId>c3p0</groupId>
      <artifactId>c3p0</artifactId>
      <version>0.9.1.2</version>
    </dependency>
    <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>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.0.5.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.8.13</version>
    </dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

②书写spring配置文件头空间约束地址

<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">
1
2
3
4
5
6
7
8
9
10
11
12
13
14

③在spring配置文件中配置数据源与事务管理器

    <!--加载jdbc.properties-->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <!--jdbc模板对象-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!--数据源对象-->
    <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>
    <!--平台事务管理器-->
    <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>
    <context:component-scan base-package="com.yunhe"></context:component-scan>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

④配置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>
1
2
3
4
5

⑤创建service层与dao层以及相应实现类

AccountDao

public interface AccountDao {
    public  int out(String outMan,double money);
    public  int in(String  inMan,double money);
}
1
2
3
4

AccountDaoImpl

@Repository("accountDao")
public class AccountDaoImpl implements AccountDao {
    @Autowired
    JdbcTemplate jdbcTemplate;
    @Override
    public int out(String outMan, double money) {

        return jdbcTemplate.update("update account set money=money-? where name=? ",money,outMan);
    }
    @Override
    public int in(String inMan, double money) {
        return jdbcTemplate.update("update account set money=money+? where name=? ",money,inMan);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

AccountService

public interface AccountService {
    public void transfer(String outMan, String inMan, double money);
}
1
2
3

AccountServiceImpl

@Service("accountService")
public class AccountServiceImpl implements AccountService {
    @Autowired
    AccountDao accountDao;

    @Override
    public void transfer(String outMan, String inMan, double money) {
        accountDao.out(outMan,money);
        int i = 1/0;
        accountDao.in(inMan,money);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

⑥测试事务的执行

    @Test
    public void tx(){
        AccountService accountServiceImpl = (AccountService) ac.getBean("accountService");
        accountServiceImpl.transfer("zhangsan","lisi",1000);
    }
1
2
3
4
5

3.4 切点方法的事务参数的配置

   <!--事务增强配置  针对事务进行进一步配置-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="*"/>
        </tx:attributes>
    </tx:advice>
1
2
3
4
5
6

在事务增强配置中可以对于切点方法进行额外的事务配置，针对于不同方法可以使用不同的配置，也可以使用*为所有事务方法配置相同的事务处理方式（默认spring使用默认配置）

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

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

四、使用注解进行spring事务管理

4.1 使用注解快速开发

①导入spring相应坐标

<dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>5.0.5.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>5.0.5.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.32</version>
    </dependency>
    <dependency>
      <groupId>c3p0</groupId>
      <artifactId>c3p0</artifactId>
      <version>0.9.1.2</version>
    </dependency>
    <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>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.0.5.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.8.13</version>
    </dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

②书写spring配置文件头空间约束地址

<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">
1
2
3
4
5
6
7
8
9
10
11
12
13
14

③书写dao层、service层、pojo实体类

Account

public class Account {
    private String name;
    private double money;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public double getMoney() {
        return money;
    }
    public void setMoney(double money) {
        this.money = money;
    }
    @Override
    public String toString() {
        return "Account{" +
                "name='" + name + '\'' +
                ", money=" + money +
                '}';
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

AccountDao

public interface AccountDao {
    public  int out(String outMan, double money);
    public  int in(String inMan, double money);
}
1
2
3
4

AccountDaoImpl

@Repository("accountDao")
public class AccountDaoImpl implements AccountDao {
    @Autowired
    JdbcTemplate jdbcTemplate;
    @Override
    public int out(String outMan, double money) {

        return jdbcTemplate.update("update account set money=money-? where name=? ",money,outMan);
    }
    @Override
    public int in(String inMan, double money) {
        return jdbcTemplate.update("update account set money=money+? where name=? ",money,inMan);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

AccountService

public interface AccountService {
    public void transfer(String outMan, String inMan, double money);
}
1
2
3

AccountServiceImpl

@Service("accountService")
//使用默认事务配置对当前类中所有方法进行事务管理
@Transactional
public class AccountServiceImpl implements AccountService {
    @Autowired
    AccountDao accountDao;
    @Override
    //也可以对指定方法事务进行额外设置
    @Transactional
    public void transfer(String outMan, String inMan, double money) {
        accountDao.out(outMan,money);
       //int i = 1/0;
        accountDao.in(inMan,money);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

④根据使用配置相应配置文件

1)spring注解开发

    <!-- 开启spring 注解扫描 -->
    <context:component-scan base-package="com.yunhe"/>
1
2

2)导入properties配置文件

    <!-- 加载类路径下的properties配置文件 -->
    <context:property-placeholder location="classpath:jdbc.properties"/>
1
2

3)数据源配置

    <!-- datasource数据源 -->
    <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>
1
2
3
4
5
6
7

4)jdbc对象与事务管理器

    <!--jdbc模板对象-->
    <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>
1
2
3
4
5
6
7
8

5)设置事务扫描

    <!-- 事务注解扫描 需要与事务注解一同使用 -->
    <tx:annotation-driven/>
1
2

⑤书写测试代码测试事务执行

    @Test
    public void tx(){
        ApplicationContext ac=new ClassPathXmlApplicationContext("spring.xml");
        AccountService accountService  = (AccountService) ac.getBean("accountService");
        accountService.transfer("zhangsan","lisi",1000);
    }
1
2
3
4
5
6

4.2 事务注解开发配置控制解析

①使用 @Transactional 在需要进行事务控制的类或是方法上修饰，注解可用的属性同 xml 配置方式，例如隔离级别、传播行为等。

②注解使用在类上，那么该类下的所有方法都使用同一套注解参数配置。

③使用在方法上，不同的方法可以采用不同的事务参数配置。

④Xml配置文件中要开启事务的注解驱动<tx:annotation-driven />
k.jdbc.datasource.DataSourceTransactionManager">


**5)设置事务扫描**

```xml
    <!-- 事务注解扫描 需要与事务注解一同使用 -->
    <tx:annotation-driven/>
1
2
3
4
5
6

⑤书写测试代码测试事务执行

    @Test
    public void tx(){
        ApplicationContext ac=new ClassPathXmlApplicationContext("spring.xml");
        AccountService accountService  = (AccountService) ac.getBean("accountService");
        accountService.transfer("zhangsan","lisi",1000);
    }
1
2
3
4
5
6

4.2 事务注解开发配置控制解析

①使用 @Transactional 在需要进行事务控制的类或是方法上修饰，注解可用的属性同 xml 配置方式，例如隔离级别、传播行为等。

②注解使用在类上，那么该类下的所有方法都使用同一套注解参数配置。

③使用在方法上，不同的方法可以采用不同的事务参数配置。

④Xml配置文件中要开启事务的注解驱动<tx:annotation-driven />

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/知新_RL/article/detail/576774