zoukankan      html  css  js  c++  java
  • Spring的事务管理

    事务

      事务:是逻辑上一组操作,要么全都成功,要么全都失败.
      事务特性(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记录

        

      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(11) NOT NULL AUTO_INCREMENT,
      `name` varchar(20) NOT NULL,
      `money` double DEFAULT NULL,
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;
    INSERT INTO `account` VALUES ('1', 'aaa', '1000');
    INSERT INTO `account` VALUES ('2', 'bbb', '1000');
    INSERT INTO `account` VALUES ('3', 'ccc', '1000');
    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);
        }
    }
  • 相关阅读:
    Window7中Eclipse运行MapReduce程序报错的问题
    Hadoop以及其外围生态系统的安装参考
    《node.js开发指南》第五章与新版Node变化太大的一些问题
    打造开发React Native的Sublime
    幸福
    近日阅读记录
    react中属性默认值是true?
    git撤销操作总结
    React Native中的DeviceEventEmitter.addListener与DeviceEventEmitter.emit
    React父子组件的一个混淆点
  • 原文地址:https://www.cnblogs.com/fengmingyue/p/6209124.html
Copyright © 2011-2022 走看看