Spring的学习（四、Spring事务管理）

Spring事务管理的三个核心接口

Spring的事务管理是基于AOP实现的，而AOP是以方法为单位的。

Spring的事务属性分别为传播行为、隔离级别、只读和超时属性。所有这些属性提供了事务应用的方法和描述策略。

事务管理的三个核心接口：PlatformTransactionManager、TransactionDefinition、TransactionStatus。

1. PlatformTransactionManager

PlatformTransactionManager接口是Spring提供的平台事务管理器，用于管理事务。该接口中提供了三个事务操作方法，具体如下：

（1）TransactionStatus getTransaction(TransactionDefinition definition)：用于获取事务状态信息。

（2）void commit(TransactionStatus status)：用于提交事务。

（3）void rollback(TransactionStatus status)：用于回滚事务。

在项目中通过XML配置事务的详细信息，Spring将这些信息封装到对象TransactionDefinition中，通过事务管理器的getTransaction()方法获得事务的状态TransactionStatus，就可以对事务进行下一步的操作。

2. TransactionDefinition

TransactionDefinition接口是事务定义（描述）对象，提供事务相关信息获取的方法，包括5个操作，具体如下：

（1）String getName()：获取事务对象名称。

（2）int getIsolationLevel()：获取事务的隔离级别。

（3）int getPropagationBehavior()：获取事务的传播行为。

（4）int getTimeout()：获取事务的超时时间。

（5）boolean isReadOnly()：获取事务是否只读。

需要注意：事务传播行为的概念，事务的传播行为是指在同一个方法中，不同操作前后所使用的事务。

在事务管理过程中，传播行为可以控制是否需要创建事务以及如何创建事务，通常情况下，数据的查询不会影响原数据的改变，所以不需要进行事务管理，而对于数据的增加、修改、删除等操作，必须进行事务管理，如果没有指定事务的传播行为，默认传播行为是required。

传播行为的种类：

属性名称 值 描述
PROPAGATION_REQUIRED required 支持当前事务。如果A方法已经在事务中，B将直接使用。如果没有将创建新事务。
PROPAGATION_SUPPORTS supports 支持当前事务。如果A方法已经在事务中，B将直接使用。如果没有将以非事务状态执行。
PROPAGATION_MANDATORY mandatory 支持当前事务。如果A方法没有事务，将抛异常。
PROPAGATION_REQUIRES_NEW requires_new 将创建新的事务，如果A方法已经在事务中，将A事务挂起。
PROPAGATION_NOT_SUPPORTED not_supported 不支持当前事务，总是以非事务状态执行。如果A方法已经在事务中，将挂起。
PROPAGATION_NEVER never 不支持当前事务，如果A方法在事务中，将抛异常。
PROPAGATION_NESTED nested 嵌套事务，底层将使用Savepoint形成嵌套事务。

3. TransactionStatus

TransactionStatus接口是事务的状态，描述了某一时间点上事务的状态信息，包含6个操作，具体如下：

（1）void flush()：刷新事务。

（2）boolean hasSavepoint()：获取是否存在保存点。

（3）boolean isCompleted()：获取事务是否完成。

（4）boolean isNewTransaction()：获取是否是新事务。

（5）boolean isRollbackOnly()：获取是否回滚。

（6）void setRollbackOnly()：设置事务回滚。

TransactionProxyFactoryBean实现声明式事务管理

Spring的事务管理分为两种方式，声明式事务管理和编程式事务管理。

编程式事务管理

使用事务模板TransactionTemplate手动地管理事务，在实际开发中一般不使用，这里了解即可。

声明式事务管理

是Spring最原始的事务管理方式，我们需要在配置文件中定义数据源和事务管理器，然后把事务管理器注入到TransactionProxyFactoryBean中，设置目标类和事务的相关属性，使用TransactionProxyFactoryBean生成代理，它的优势在于代码中无须关注事务逻辑，而是交给Spring容器进行事务控制。

数据库：表名：acount 字段：id name money 存两组值：1，jack，1000/2，rose，1000。

c3p0-db.properties

jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.jdbcUrl=jdbc:mysql:///spring
jdbc.user=root
jdbc.password=root

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:aop="http://www.springframework.org/schema/aop"
       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/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">

        <!--加载properties文件 -->
        <context:property-placeholder location="classpath:c3p0-db.properties"/>
        <!--配置数据源，读取properties文件信息 -->
        <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
            <property name="driverClass" value="${jdbc.driverClass}"></property>
            <property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
            <property name="user" value="${jdbc.user}"></property>
            <property name="password" value="${jdbc.password}"></property>
        </bean>
        <!--配置JDBC模板 -->
        <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
            <property name="jdbcTemplate" ref="dataSource"></property>
        </bean>
        <!--配置dao -->
        <bean id="accountDao" class="cn.tm.dao.impl.AccountDaoImpl">
            <property name="jdbcTemplate" ref="jdbcTemplate"></property>
        </bean>
        <!--配置service -->
        <bean id="accountService" class="cn.tm.dao.impl.AccountServiceImpl">
            <property name="accountDao" ref="accountDao"></property>
        </bean>
        <!--事务管理器，依赖于数据源 -->
        <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
            <property name="dataSource" ref="dataSource"></property>
        </bean>
        <!--生成代理类，让代理管理事务，依赖于事务管理器 -->
        <bean id="accountServiceProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
            <!--提供事务管理器 -->
            <property name="transactionManager" ref="transactionManager"></property>
            <!--目标类 -->
            <property name="target" ref="accountService"></property>
            <!--提供接口 -->
            <property name="proxyInterfaces" value="cn.tm.service.AccountService"></property>
            <!--事务的详情配置，给TransactionDefinition进行赋值 -->
            <property name="transactionAttributes">
                <props>
                    <!--key属性用来配置对目标内的哪些方法进行增强，*代表所有方法，如果是save*，表示以save开头的方法 -->
                    <!--text文本按照固定的格式编写事务的详情及TransactionDefinition的内容，例如传播行为、隔离界别等，值之间用逗号隔开 -->
                    <prop key="*">PROPAGATION_REQUIRED,ISOLATION_REPEATABLE_READ</prop>
                </props>
            </property>
        </bean>
</beans>

AcountDao.java+AccountDaoImpl.java

package cn.tm.dao;
public interface AccountDao{
    //汇款
    public void out(String outUser,int money);
    //收款
    public void in(String inUser,int money);
}

package cn.tm.dao.impl;
public class AccountDaoImpl implements AccountDao{
    private JdbcTemplate jdbcTemplate;
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate){
        this.jdbcTemplate = jdbcTemplate;
    }
    //汇款的实现方法
    public void out(String outUser, int money) {
        this.jdbcTemplate.update("update account set money = money-?"+"where name=?",money,outUser);
    }
    //收款的实现方法
    public void in(String inUser, int money) {
        this.jdbcTemplate.update("update account set money = money+?"+"where name=?",money,inUser);
    }
}

AccountService.java+AccountServiceImpl.java

package cn.tm.service;
public interface AccountService{
    //转账方法
    public void transfer(String outUser,String inUser,int money);
}

package cn.tm.service.impl;
public class AccountServiceImpl implements AccountService{
    private AccountDao accountDao;
    public void setAccountDao(AccountDao accountDao){
        this.accountDao = accountDao;
    }
    @Override
    public void transfer(String outUser, String inUser, int money) {
        this.accountDao.out(outUser,money);
        this.accountDao.in(inUser,money);
    }
}

测试类

public class Test{
    public static void main(String[] args) {
        //xmlPath为applicationContext.xml文件的路径
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
        AccountService accountService = (AccountService)applicationContext.getBean("accountServiceProxy");
        //从jack的账户转100到rose的账户上
        accountService.transfer("jack","rose",100);
        System.out.println("ok");
    }
}

效果：

jack剩余900元，rose剩余1100元。如果转账的代码有问题，比如出现1/0这种情况，则两人钱仍然是1000元。

Spring AOP XML方式

上面的TransactionProxyFactoryBean实现声明式事务管理缺点是配置文件过于臃肿、难以阅读。因此，Spring提供了基于tx/AOP配置的声明式事务管理方式，也是实际开发中最常用的一种方式。其他代码同上，只修改了applicationContext.xml和测试类的代码。

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

        <!--加载properties文件 -->
        <context:property-placeholder location="classpath:c3p0-db.properties"/>
        <!--配置数据源，读取properties文件信息 -->
        <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
            <property name="driverClass" value="${jdbc.driverClass}"></property>
            <property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
            <property name="user" value="${jdbc.user}"></property>
            <property name="password" value="${jdbc.password}"></property>
        </bean>
        <!--配置JDBC模板 -->
        <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
            <property name="jdbcTemplate" ref="dataSource"></property>
        </bean>
        <!--配置dao -->
        <bean id="accountDao" class="cn.tm.dao.impl.AccountDaoImpl">
            <property name="jdbcTemplate" ref="jdbcTemplate"></property>
        </bean>
        <!--配置service -->
        <bean id="accountService" class="cn.tm.dao.impl.AccountServiceImpl">
            <property name="accountDao" ref="accountDao"></property>
        </bean>
        <!--事务管理器，依赖于数据源 -->
        <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
            <property name="dataSource" ref="dataSource"></property>
        </bean>
        <!--编写通知：对事物进行增强（通知），需要编写对切入点和具体执行事务细节 -->
        <tx:advice id="txAdvice" transaction-manager="txManager">
            <tx:attributes>
                <!-- tx:method给切入点方法添加事务详情 name：方法名称，*表示任意方法名称，save* 即是以save开头  -->
                <!-- propagation:设置传播行为  isolation:隔离级别  read-only:是否只读  -->
                <tx:method name="*" propagation="REQUIRED" isolation="DEFAULT" read-only="false"/>
            </tx:attributes>
        </tx:advice>
        <!--aop编写，让Spring自动对目标生成代理，需要使用AspectJ的表达式 -->
        <aop:config>
            <!--切入点 -->
            <aop:pointcut expression="execution(* cn.tm.service.*.*(..))" id="txPointCut"/>
            <!--切面：将切入点与通知整合 -->
            <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
        </aop:config>
</beans>

测试类：（getBean内的内容做了修改）

public class Test{
    public static void main(String[] args) {
        //xmlPath为applicationContext.xml文件的路径
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
        AccountService accountService = (AccountService)applicationContext.getBean("accountService");
        //从jack的账户转100到rose的账户上
        accountService.transfer("jack","rose",100);
        System.out.println("ok");
    }
}

Spring AOP Annotation方式

Spring的声明式事务管理还可以通过Annotation注解的方式，这种方式很简单。我们需要做的只有两步：Spring容器中注册驱动，在需要使用事务的业务类或者方法上添加注解@Transactional。

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

        <!--加载properties文件 -->
        <context:property-placeholder location="classpath:c3p0-db.properties"/>
        <!--配置数据源，读取properties文件信息 -->
        <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
            <property name="driverClass" value="${jdbc.driverClass}"></property>
            <property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
            <property name="user" value="${jdbc.user}"></property>
            <property name="password" value="${jdbc.password}"></property>
        </bean>
        <!--配置JDBC模板 -->
        <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
            <property name="jdbcTemplate" ref="dataSource"></property>
        </bean>
        <!--配置dao -->
        <bean id="accountDao" class="cn.tm.dao.impl.AccountDaoImpl">
            <property name="jdbcTemplate" ref="jdbcTemplate"></property>
        </bean>
        <!--配置service -->
        <bean id="accountService" class="cn.tm.dao.impl.AccountServiceImpl">
            <property name="accountDao" ref="accountDao"></property>
        </bean>
        <!--事务管理器 -->
        <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
            <property name="dataSource" ref="dataSource"></property>
        </bean>
        <!--注册事务管理驱动 -->
        <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>
</beans>

AccountServiceImpl.java

package cn.tm.service.impl;
/*这里添加Transactional注解，并且使用注解的参数配置了事务详情，参数之间用逗号进行分隔*/
@Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.DEFAULT,readOnly = false)
public class AccountServiceImpl implements AccountService{
    private AccountDao accountDao;
    public void setAccountDao(AccountDao accountDao){
        this.accountDao = accountDao;
    }
    @Override
    public void transfer(String outUser, String inUser, int money) {
        this.accountDao.out(outUser,money);
        this.accountDao.in(inUser,money);
    }
}

参考:

1. 《SSH框架整合实战教程》

持续更新！！！

原文地址：https://www.cnblogs.com/flyinghome/p/12628525.html

时间： 2024-10-08 00:26:38

Spring的学习（四、Spring事务管理）的相关文章

SpringMVC学习(四)——Spring、MyBatis和SpringMVC的整合

之前我整合了Spring和MyBatis这两个框架,不会的可以看我的文章MyBatis框架的学习(六)——MyBatis整合Spring.本文我再来讲SpringMVC和MyBatis整合开发的方法,这样的话,Spring.MyBatis和SpringMVC三大框架的整合开发我们就学会了.这里我使用的Spring是Spring4.1.3这个版本(SpringMVC自然也是这个版本),MyBatis是MyBatis3.2.7这个版本. 为了更好的学习SpringMVC和MyBatis整合开发的方法

Spring 使用注解方式进行事务管理

使用步骤: 步骤一.在spring配置文件中引入<tx:>命名空间<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation

Spring中实现多数据源事务管理

Spring中实现多数据源事务管理 前言 由于项目中引入了多个数据源,并且需要对多个数据源进行写操作,那么多数据源的事务管理自然成了不可避免的问题,这也让我对@Transactional注解有了进一步的理解(但实际上也并不是非常深入) 然而这是一个演进的过程,刚开始项目中并没有使用@Transactional指定具体的TransactionManager,所以新增一个数据源后,对原有的事务产生了影响了,这也是偶尔在一次测试报错而结果没有回滚之后才发现的,遂对于@Transactional注解的一

【转】Spring 使用注解方式进行事务管理

Spring 使用注解方式进行事务管理 原文链接 http://www.cnblogs.com/younggun/archive/2013/07/16/3193800.html#top 使用步骤: 步骤一.在spring配置文件中引入<tx:>命名空间 <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-i

spring boot配置mybatis和事务管理

spring boot配置mybatis和事务管理 一.spring boot与mybatis的配置 1.首先,spring boot 配置mybatis需要的全部依赖如下: <!-- Spring Boot 启动父依赖 --> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId>

Spring整合JMS（四）——事务管理

原文链接:http://haohaoxuexi.iteye.com/blog/1983532 Spring提供了一个JmsTransactionManager用于对JMS ConnectionFactory做事务管理.这将允许JMS应用利用Spring的事务管理特性.JmsTransactionManager在执行本地资源事务管理时将从指定的ConnectionFactory绑定一个ConnectionFactory/Session这样的配对到线程中.JmsTemplate会自动检测这样的事务资

spring+mybatis之声明式事务管理初识(小实例)

前几篇的文章都只是初步学习spring和mybatis框架,所写的实例也都非常简单,所进行的数据访问控制也都很简单,没有加入事务管理.这篇文章将初步接触事务管理. 1.事务管理 理解事务管理之前,先通过一个例子讲一下什么是事务管理:取钱. 比如你去ATM机取1000块钱,大体有两个步骤:首先输入密码金额,银行卡扣掉1000元钱:然后ATM出1000元钱.这两个步骤必须是要么都执行要么都不执行.如果银行卡扣除了1000块但是ATM出钱失败的话,你将会损失1000元:如果银行卡扣钱失败但是ATM却出

Spring in action读书笔记-事务管理

在软件开发领域,全有全无的操作被称为事务 事务的四个特性(ACID): 原子性(Atomtic):事务是由一个或多个活动所组成的一个工作单元,要么全部发生,要么全部不发生. 一致性(Consistent):一旦事务完成,系统应确保它所建的业务处于一致的状态. 隔离性(Isolated):事务允许多个用户操作同样的数据,但不能相互影响. 持久性(Durable):事务的结果应该存到数据库或者其他形式的持久化存储中. spring对事务管理的支持: 编码式:允许用户在代码中精确定义事务的边界 声明式

Spring事务隔离级别与传播机制，spring+mybatis+atomikos实现分布式事务管理

本文转载于本人另一博客[http://blog.csdn.net/liaohaojian/article/details/68488150] 1.事务的定义:事务是指多个操作单元组成的合集,多个单元操作是整体不可分割的,要么都操作不成功,要么都成功.其必须遵循四个原则(ACID). 原子性(Atomicity):即事务是不可分割的最小工作单元,事务内的操作要么全做,要么全不做: 一致性(Consistency):在事务执行前数据库的数据处于正确的状态,而事务执行完成后数据库的数据还是应该处于正确

spring事务隔离级别、传播行为以及spring+mybatis+atomikos实现分布式事务管理

转载自:http://blog.csdn.net/liaohaojian/article/details/68488150 1.事务的定义:事务是指多个操作单元组成的合集,多个单元操作是整体不可分割的,要么都操作不成功,要么都成功.其必须遵循四个原则(ACID). 原子性(Atomicity):即事务是不可分割的最小工作单元,事务内的操作要么全做,要么全不做: 一致性(Consistency):在事务执行前数据库的数据处于正确的状态,而事务执行完成后数据库的数据还是应该处于正确的状态,即数据完整