Spring的事务管理

时间：2023-03-08 16:58:15

事务

　　事务:是逻辑上一组操作，要么全都成功，要么全都失败.
　　事务特性（ACID）
　　　　原子性:事务不可分割
　　　　一致性:事务执行的前后，数据完整性保持一致
　　　　隔离性:一个事务执行的时候，不应该受到其他事务的打扰
　　　　持久性:一旦结束，数据就永久的保存到数据库
　　如果不考虑隔离性
　　　　脏读:一个事务读到另一个事务未提交数据
　　　　不可重复读:一个事务读到另一个事务已经提交数据（update）导致一个事务多次查询结果不一致
　　　　虚读:一个事务读到另一个事务已经提交数据（insert）导致一个事务多次查询结果不一致
　　事务的隔离级别
　　　　未提交读:以上情况都有可能发生。
　　　　已提交读:避免脏读，但不可重复读，虚读是有可能发生。
　　　　可重复读:避免脏读，不可重复读，但是虚读有可能发生。
　　　　串行的:避免以上所有情况.
Spring中事务管理
　　Spring提供事务管理API（三个接口）
　　　　PlatformTransactionManager:平台事务管理器
　　　　　　commit(TransactionStatus status)
　　　　　　getTransaction(TransactionDefinition definition)
　　　　　　rollback(TransactionStatus status)
　　　　TransactionDefinition:事务定义信息(隔离、传播、超时、只读)
　　　　　　ISOLATION_XXX:事务隔离级别
　　　　　　PROPAGATION_XXX:事务的传播行为(不是JDBC中有的，为了解决实际开发问题.)
　　　　TransactionStatus:事务状态
　　　　　　是否有保存点
　　　　　　是否一个新的事务
　　　　　　事务是否已经提交

　　　　关系:PlatformTransactionManager通过TransactionDefinition设置事务相关信息管理事务，管理事务过程中，产生一些事务状态:状态由TransactionStatus记录

　　　　Spring的事务管理

　　API详解
　　　　PlatformTransactionManager
　　　　　　Spring为不同的持久化框架提供了不同PlatformTransactionManager接口实现
　　　　　　　　org.springframework.jdbc.datasource.DataSourceTransactionManager : 使用Spring JDBC或iBatis 进行持久化数据时使用
　　　　　　　　org.springframework.orm.hibernate3.HibernateTransactionManager : 使用Hibernate3.0版本进行持久化数据时使用
　　　　　　　　org.springframework.orm.jpa.JpaTransactionManager 使用JPA进行持久化时使用
　　　　　　　　org.springframework.jdo.JdoTransactionManager 当持久化机制是Jdo时使用
　　　　　　　　org.springframework.transaction.jta.JtaTransactionManager 使用一个JTA实现来管理事务，在一个事务跨越多个资源时必须使用
　　　　TransactionDefinition接口
　　　　　　ISOLATION_DEFAULT:默认级别（Mysql:repeatable_read oracle:read_commited）
　　　　　　ISOLATION_READ_UNCOMMITTED
　　　　　　ISOLATION_READ_COMMITTED
　　　　　　ISOLATION_REPEATABLE_READ
　　　　　　ISOLATION_SERIALIZABLE
　　　　　　事务的传播行为:(不是JDBC事务管理，用来解决实际开发的问题)传播行为：解决业务层之间的调用的事务的关系
　　　　　　　　PROPAGATION_REQUIRED :支持当前事务，如果不存在 就新建一个
　　　　　　　　　　A,B 如果A有事务，B使用A的事务，如果A没有事务，B就开启一个新的事务.(A,B是在一个事务中。)
　　　　　　　　PROPAGATION_SUPPORTS :支持当前事务，如果不存在，就不使用事务
　　　　　　　　　　A,B 如果A有事务，B使用A的事务，如果A没有事务，B就不使用事务.
　　　　　　　　PROPAGATION_MANDATORY :支持当前事务，如果不存在，抛出异常
　　　　　　　　　　A,B 如果A有事务，B使用A的事务，如果A没有事务，抛出异常.
　　　　　　　　PROPAGATION_REQUIRES_NEW 如果有事务存在，挂起当前事务，创建一个新的事务
　　　　　　　　　　A,B 如果A有事务，B将A的事务挂起，重新创建一个新的事务.(A,B不在一个事务中.事务互不影响.)
　　　　　　　　PROPAGATION_NOT_SUPPORTED 以非事务方式运行，如果有事务存在，挂起当前事务
　　　　　　　　　　A,B 非事务的方式运行，A有事务，就会挂起当前的事务.
　　　　　　　　PROPAGATION_NEVER 以非事务方式运行，如果有事务存在，抛出异常
　　　　　　　　PROPAGATION_NESTED 如果当前事务存在，则嵌套事务执行（基于SavePoint技术）
　　　　　　　　　　A,B A有事务，A执行之后，将A事务执行之后的内容保存到SavePoint.B事务有异常的话，用户需要自己设置事务提交还是回滚.
Spring的事务管理（分为两类）
　　　　编程式事务管理:手动编写代码完成事务管理（麻烦，实际中很少用）
　　　　声明式事务管理:不需要手动编写代码,配置（推荐使用）
事务操作的环境搭建

CREATE TABLE `account` (

　　`id` int() NOT NULL AUTO_INCREMENT,

　　`name` varchar() NOT NULL,

　　`money` double DEFAULT NULL,

　　PRIMARY KEY (`id`)

) ENGINE=InnoDB AUTO_INCREMENT= DEFAULT CHARSET=utf8;

INSERT INTO `account` VALUES ('', 'aaa', '');

INSERT INTO `account` VALUES ('', 'bbb', '');

INSERT INTO `account` VALUES ('', 'ccc', '');
public interface AccountDao {

    /**

     * 转出的方法

     * @param from    :转出的人

     * @param money    :要转账金额

     */

    public void out(String from,Double money);

    /**

     * 转出的方法

     * @param to    :转入的人

     * @param money    :要转账金额

     */

    public void in(String to,Double money);

}

AccountDao

public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao {

    /**

     * 转出的方法

     * @param from    :转出的人

     * @param money    :要转账金额

     */

    public void out(String from, Double money) {

        String sql = "update account set money = money - ? where name  = ?";

        this.getJdbcTemplate().update(sql, money,from);

    }

    /**

     * 转出的方法

     * @param to    :转入的人

     * @param money    :要转账金额

     */

    public void in(String to, Double money) {

        String sql = "update account set money = money + ? where name  = ?";

        this.getJdbcTemplate().update(sql, money , to);

    }

}

AccountDaoImpl 

public interface AccountService {

    /**

     * 转账的方法

     * @param from:从哪转出

     * @param to:转入的人

     * @param money:转账金额

     */

    public void transfer(String from,String to,Double money);

}

AccountService

Spring的事务管理
　　手动编码的方式完成事务管理(缺点:代码量增加,代码有侵入性)

　　　　在AccountService中使用TransactionTemplate,TransactionTemplate依赖DataSourceTransactionManager,DataSourceTransactionManager依赖DataSource构造

public class AccountServiceImpl implements AccountService {

    private AccountDao accountDao;

    private TransactionTemplate transactionTemplate;

    public void setAccountDao(AccountDao accountDao) {

        this.accountDao = accountDao;

    }

    public void setTransactionTemplate(TransactionTemplate transactionTemplate) {

        this.transactionTemplate = transactionTemplate;

    }

    public void transfer(final String from, final String to, final Double money) {

        transactionTemplate.execute(new TransactionCallbackWithoutResult() {

            @Override

            protected void doInTransactionWithoutResult(TransactionStatus status) {

                accountDao.out(from, money);

                //int d = 1 / 0;

                accountDao.in(to, money);

            }

        });

    }

}
<?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"

       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">

    <!-- 引入外部属性文件. -->

    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!-- 配置c3p0连接池 -->

    <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.user}"/>

        <property name="password" value="${jdbc.password}"/>

    </bean>

    <!-- 业务层类 -->

    <bean id="accountService" class="cn.yzu.spring3.demo1.AccountServiceImpl">

        <!-- 在业务层注入Dao -->

        <property name="accountDao" ref="accountDao"/>

        <!-- 在业务层注入事务的管理模板 -->

        <property name="transactionTemplate" ref="transactionTemplate"/>

    </bean>

    <!-- 持久层类 -->

    <bean id="accountDao" class="cn.yzu.spring3.demo1.AccountDaoImpl">

        <!-- 注入连接池的对象,通过连接池对象创建模板. -->

        <property name="dataSource" ref="dataSource"/>

    </bean>

    <!-- 事务管理的模板 -->

    <bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">

        <property name="transactionManager" ref="transactionManager"/>

    </bean>

    <!-- 配置事务管理器 -->

    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

        <!-- 需要注入连接池,通过连接池获得连接 -->

        <property name="dataSource" ref="dataSource"/>

    </bean>

</beans>
@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration("classpath:applicationContext.xml")

public class SpringTest1 {

    @Autowired

    @Qualifier("accountService")

    private AccountService accountService;

    @Test

    public void demo1(){

        // 完成转账

        accountService.transfer("aaa", "bbb", 100d);

    }

}

　　声明式事务管理(原始方式,基于TransactionProxyFactoryBean,缺点:就是需要为每一个管理事务的类生成代理.需要为每个类都需要进行配置)

public class AccountServiceImpl implements AccountService {

    private AccountDao accountDao;

    public void setAccountDao(AccountDao accountDao) {

        this.accountDao = accountDao;

    }

    public void transfer(final String from, final String to, final Double money) {

        accountDao.out(from, money);

        //int d = 1 / 0;

        accountDao.in(to, money);

    }

}
<?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"

       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">

    <!-- 引入外部属性文件. -->

    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!-- 配置c3p0连接池 -->

    <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.user}"/>

        <property name="password" value="${jdbc.password}"/>

    </bean>

    <!-- 业务层类 -->

    <bean id="accountService" class="cn.yzu.spring3.demo2.AccountServiceImpl">

        <!-- 在业务层注入Dao -->

        <property name="accountDao" ref="accountDao"/>

    </bean>

    <!-- 持久层类 -->

    <bean id="accountDao" class="cn.yzu.spring3.demo2.AccountDaoImpl">

        <!-- 注入连接池的对象,通过连接池对象创建模板. -->

        <property name="dataSource" ref="dataSource"/>

    </bean>

    <!-- 事务管理器 -->

    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

        <!-- 注入连接池 -->

        <property name="dataSource" ref="dataSource"/>

    </bean>

    <!-- 配置生成代理对象 -->

    <bean id="accountServiceProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">

        <!-- 目标对象 -->

        <property name="target" ref="accountService"/>

        <!-- 注入事务管理器 -->

        <property name="transactionManager" ref="transactionManager"/>

        <!-- 事务的属性设置 -->

        <!-- prop格式：PROPAGATION,ISOLATION,readOnly,-Exception,+Exception

            顺序:传播行为、隔离级别、事务是否只读、发生哪些异常可以回滚事务（所有的异常都回滚）、发生了哪些异常不回滚 -->

        <property name="transactionAttributes">

            <props>

                <prop key="transfer">PROPAGATION_REQUIRED</prop>

            </props>

        </property>

    </bean>

</beans>
@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration("classpath:applicationContext2.xml")

public class SpringTest2 {

    @Autowired

    @Qualifier("accountServiceProxy")//千万注意:注入代理对象

    private AccountService accountService;

    @Test

    public void demo1(){

        accountService.transfer("aaa", "bbb", 100d);

    }

}

　　声明式事务管理:(自动代理.基于切面 ******)

public class AccountServiceImpl implements AccountService {

    private AccountDao accountDao;

    public void setAccountDao(AccountDao accountDao) {

        this.accountDao = accountDao;

    }

    public void transfer(final String from, final String to, final Double money) {

        accountDao.out(from, money);

        //int d = 1 / 0;

        accountDao.in(to, money);

    }

}
<?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"

    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

    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">

    <!-- 引入外部属性文件. -->

    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!-- 配置c3p0连接池 -->

    <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.user}"/>

        <property name="password" value="${jdbc.password}"/>

    </bean>

    <!-- 业务层类 -->

    <bean id="accountService" class="cn.yzu.spring3.demo3.AccountServiceImpl">

        <!-- 在业务层注入Dao -->

        <property name="accountDao" ref="accountDao"/>

    </bean>

    <!-- 持久层类 -->

    <bean id="accountDao" class="cn.yzu.spring3.demo3.AccountDaoImpl">

        <!-- 注入连接池的对象,通过连接池对象创建模板. -->

        <property name="dataSource" ref="dataSource"/>

    </bean>

    <!-- 事务管理器 -->

    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

        <property name="dataSource" ref="dataSource"/>

    </bean>

    <!-- 定义一个增强 -->

    <tx:advice id="txAdvice" transaction-manager="transactionManager">

        <!-- 增强(事务)的属性的配置 -->

        <tx:attributes>

            <!--

                isolation:DEFAULT    :事务的隔离级别.

                propagation            :事务的传播行为.

                read-only            :false.不是只读

                timeout                :-1

                no-rollback-for        :发生哪些异常不回滚

                rollback-for        :发生哪些异常回滚事务

             -->

            <tx:method name="transfer" isolation="DEFAULT"/>

        </tx:attributes>

    </tx:advice>

    <!-- aop配置定义切面和切点的信息 -->

    <aop:config>

        <!-- 定义切点:哪些类的哪些方法应用增强 -->

        <aop:pointcut expression="execution(* cn.itcast.spring3.demo3.AccountService+.*(..))" id="mypointcut"/>

        <!-- 定义切面: -->

        <aop:advisor advice-ref="txAdvice" pointcut-ref="mypointcut"/>

    </aop:config>

</beans>
@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration("classpath:applicationContext3.xml")

public class SpringTest3 {

    @Autowired

    @Qualifier("accountService")//注入Service对象,不需要注入代理对象(生成这个类的时候,已经是代理对象)

    private AccountService accountService;

    @Test

    public void demo1(){

        accountService.transfer("aaa", "bbb", 100d);

    }

}

　　基于注解的事务管理

//注解中有属性值:isolation,propagation,readOnly...

@Transactional(isolation=Isolation.DEFAULT,propagation=Propagation.REQUIRED,readOnly=false)

public class AccountServiceImpl implements AccountService {

    private AccountDao accountDao;

    public void setAccountDao(AccountDao accountDao) {

        this.accountDao = accountDao;

    }

    public void transfer(final String from, final String to, final Double money) {

        accountDao.out(from, money);

        int d = 1 / 0;

        accountDao.in(to, money);

    }

}
<?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"

    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

    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">

    <!-- 引入外部属性文件. -->

    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!-- 配置c3p0连接池 -->

    <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.user}"/>

        <property name="password" value="${jdbc.password}"/>

    </bean>

    <!-- 业务层类 -->

    <bean id="accountService" class="cn.yzu.spring3.demo4.AccountServiceImpl">

        <!-- 在业务层注入Dao -->

        <property name="accountDao" ref="accountDao"/>

    </bean>

    <!-- 持久层类 -->

    <bean id="accountDao" class="cn.yzu.spring3.demo4.AccountDaoImpl">

        <!-- 注入连接池的对象,通过连接池对象创建模板. -->

        <property name="dataSource" ref="dataSource"/>

    </bean>

    <!-- 事务管理器 -->

    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

        <property name="dataSource" ref="dataSource"/>

    </bean>

    <!-- 开启注解的事务管理 -->

    <tx:annotation-driven transaction-manager="transactionManager"/>

</beans>
@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration("classpath:applicationContext4.xml")

public class SpringTest4 {

    @Autowired

    @Qualifier("accountService")

    private AccountService accountService;

    @Test

    public void demo1(){

        accountService.transfer("aaa", "bbb", 100d);

    }

}

相关文章