Spring学习8-Spring事务管理（AOP/声明式式事务管理）

一、基础知识普及
声明式事务的事务属性：

一：传播行为
二：隔离级别
三：只读提示
四：事务超时间隔
五:异常：指定除去RuntimeException其他回滚异常。
传播行为：
所谓事务的传播行为是指，如果在开始当前事务之前，一个事务上下文已经存在，此时有若干选项可以指定一个事务性方法的执行行为。

spring的事务传播规则：

传播行为	意义
PROPAGATION_REQUIRED	如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。
PROPAGATION_REQUIRES_NEW	创建一个新的事务，如果当前存在事务，则把当前事务挂起。
PROPAGATION_SUPPORTS	如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。
PROPAGATION_NOT_SUPPORTED	以非事务方式运行，如果当前存在事务，则把当前事务挂起。
PROPAGATION_NEVER	以非事务方式运行，如果当前存在事务，则抛出异常
PROPAGATION_MANDATORY	如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。
PROPAGATION_NESTED	如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行；如果当前没有事务，则该取值等价于TransactionDefinition.PROPAGATION_REQUIRED。

这里需要指出的是，前面的六种事务传播行为是 Spring 从EJB 中引入的，他们共享相同的概念。而 PROPAGATION_NESTED是 Spring 所特有的。以PROPAGATION_NESTED启动的事务内嵌于外部事务中（如果存在外部事务的话），此时，内嵌事务并不是一个独立的事务，它依赖于外部事务的存在，只有通过外部的事务提交，才能引起内部事务的提交，嵌套的子事务不能单独提交。如果熟悉 JDBC中的保存点（SavePoint）的概念，那嵌套事务就很容易理解了，其实嵌套的子事务就是保存点的一个应用，一个事务中可以包括多个保存点，每一个嵌套子事务。另外，外部事务的回滚也会导致嵌套子事务的回滚。
隔离级别：
隔离级别是指若干个并发的事务之间的隔离程度：

spring的事务隔离级别：

隔离级别	含义
ISOLATION_DEFAULT	这是默认值，表示使用底层数据库的默认隔离级别。对大部分数据库而言，通常这值就是ISOLATION_READ_COMMITTED。
ISOLATION_READ_UNCOMMITTED	该隔离级别表示一个事务可以读取另一个事务修改但还没有提交的数据。该级别不能防止脏读和不可重复读，因此很少使用该隔离级别。
ISOLATION_READ_COMMITTED	该隔离级别表示一个事务只能读取另一个事务已经提交的数据。该级别可以防止脏读，这也是大多数情况下的推荐值。
ISOLATION_REPEATABLE_READ	该隔离级别表示一个事务在整个过程中可以多次重复执行某个查询，并且每次返回的记录都相同。即使在多次查询之间有新增的数据满足该查询，这些新增的记录也会被忽略。该级别可以防止脏读和不可重复读。
ISOLATION_SERIALIZABLE	所有的事务依次逐个执行，这样事务之间就完全不可能产生干扰，也就是说，该级别可以防止脏读、不可重复读以及幻读。但是这将严重影响程序的性能。通常情况下也不会用到该级别。

只读提示：
SessionFlush设置为none(readOnly);
事务的只读属性是指，对事务性资源进行只读操作或者是读写操作。所谓事务性资源就是指那些被事务管理的资源，比如数据源、 JMS资源，以及自定义的事务性资源等等。如果确定只对事务性资源进行只读操作，那么我们可以将事务标志为只读的，以提高事务处理的性能。在TransactionDefinition 中以 boolean 类型来表示该事务是否只读。

事务超时间隔：
所谓事务超时，就是指一个事务所允许执行的最长时间，如果超过该时间限制但事务还没有完成，则自动回滚事务。在TransactionDefinition 中以 int 的值来表示超时时间，其单位是秒。
声明式事务使用范例：
  二、声明式事务配置的5中方式(方式四最常用)
   方式一、基于Spring1.x,使用TransactionProxyFactoryBean为每个Bean生成一个代理。
    <?xml version="1.0"encoding="UTF-8"?>
<beansxmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xmlns:aop="http://www.springframework.org/schema/aop"
   xsi:schemaLocation="http://www.springframework.org/schema/beans
          http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
          http://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

<beanid="transactionManager"      class="org.springframework.orm.hibernate3.HibernateTransactionManager">
       <property name="sessionFactory" ref="sessionFactory"/>
   </bean>

   
    
    <bean id="fundService"
     class="com.jack.fund.service.serviceimpl.FundService">
     <property name="producedao">
      <ref bean="fundProduceDAO" />
     </property>
    </bean>

    <beanid="fundServiceProxy"
     class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
     
     <propertyname="transactionManager">
      <ref bean="transactionManager"/>
     </property>
     
     <propertyname="proxyTargetClass">
      <value>false</value>
     </property>
     
     <propertyname="proxyInterfaces">
      <value>com.jack.fund.service.IFundService</value>
     </property>
     
     <property name="target">
      <ref bean="fundService" />
     </property>
     
     <propertyname="transactionAttributes">
      <props>
       <propkey="delete*">PROPAGATION_REQUIRED</prop>
       <propkey="add*">PROPAGATION_REQUIRED</prop>
       <propkey="update*">PROPAGATION_REQUIRED</prop>
       <propkey="save*">PROPAGATION_REQUIRED</prop>
       <prop  key="find*">PROPAGATION_REQUIRED,readOnly</prop>
      </props>
     </property>
    </bean>
</beans>
    可以看出它适用于你的库表比较少的情况下，针对每一个功能模块配置一个业务代理服务。如果模块多大话，就显得代码有点多了，发现他们只是稍微一点不一样。这时我们就应该想到继承的思想。用第二种方法。

方式二、基于Spring1.x,使用TransactionProxyFactoryBean为所有Bean共享一个代理基类。
   <?xml version="1.0"encoding="UTF-8"?>
<beansxmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xmlns:aop="http://www.springframework.org/schema/aop"
   xsi:schemaLocation="http://www.springframework.org/schema/beans
          http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
          http://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

<bean id="transactionManager"
       class="org.springframework.orm.hibernate3.HibernateTransactionManager">
       <property name="sessionFactory" ref="sessionFactory"/>
   </bean>

    
    <beanid="transactionBase"   class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"
     lazy-init="true" abstract="true">
     
     <propertyname="transactionManager">
      <ref bean="transactionManager"/>
     </property>
     
     <propertyname="transactionAttributes">
      <props>
       <propkey="delete*">PROPAGATION_REQUIRED</prop>
       <propkey="add*">PROPAGATION_REQUIRED</prop>
       <propkey="update*">PROPAGATION_REQUIRED</prop>
       <propkey="save*">PROPAGATION_REQUIRED</prop>
       <propkey="find*">PROPAGATION_REQUIRED,readOnly</prop>
      </props>
     </property>
    </bean>
    

   
    <bean id="fundService"
     class="com.jack.fund.service.serviceimpl.FundService">
     <property name="producedao">
      <ref bean="fundProduceDAO" />
     </property>
    </bean>
    <bean id="fundServiceProxy"parent="transactionBase" >
     <property name="target">
     <ref bean="fundService" />
     </property>
    </bean>
</beans>
这样配置的话，如果有多个像fundService这样模块时，可以少些很多重复的代码。

方式三、基于SpringAOP的拦截器(主要利用BeanNameAutoProxyCreator自动创建事务代理)
<?xml version="1.0"encoding="UTF-8"?>
<beansxmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xmlns:aop="http://www.springframework.org/schema/aop"
   xsi:schemaLocation="http://www.springframework.org/schema/beans
          http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
          http://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

<bean id="transactionManager"
       class="org.springframework.orm.hibernate3.HibernateTransactionManager">
       <property name="sessionFactory" ref="sessionFactory"/>
   </bean>
    <bean id="transactionInterceptor"    class="org.springframework.transaction.interceptor.TransactionInterceptor">
       <property name="transactionManager"ref="transactionManager" />
       
     <propertyname="transactionAttributes">
      <props>
       <propkey="delete*">PROPAGATION_REQUIRED</prop>
       <propkey="add*">PROPAGATION_REQUIRED</prop>
       <propkey="update*">PROPAGATION_REQUIRED</prop>
       <propkey="save*">PROPAGATION_REQUIRED</prop>
       <propkey="find*">PROPAGATION_REQUIRED,readOnly</prop>
      </props>
     </property>
   </bean>
    <beanclass="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
       <property name="beanNames">
           <list>
           
               <value>*Service</value>
           </list>
       </property>
       <propertyname="interceptorNames">
           <list>
               <value>transactionInterceptor</value>
           </list>
       </property>
   </bean>
    
   
    <bean id="fundService"
     class="com.jack.fund.service.serviceimpl.FundService">
     <property name="producedao">
      <ref bean="fundProduceDAO" />
     </property>
    </bean>
</beans>

方式四、基于Spring2.x，使用tx标签配置的拦截器
<?xml version="1.0"encoding="UTF-8"?>
<beansxmlns="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"
   xsi:schemaLocation="http://www.springframework.org/schema/beans
          http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
          http://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop-2.5.xsd
          http://www.springframework.org/schema/txhttp://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
<beanid="sessionFactory"     class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
       <property name="configLocation"value="classpath:hibernate.cfg.xml" />
       <property name="configurationClass"value="org.hibernate.cfg.AnnotationConfiguration"/>
   </bean>

<tx:advice id="txAdvice"transaction-manager="transactionManager">
       <tx:attributes>
           <tx:method name="get*" read-only="true"rollback-for="java.lang.Exception"/>
                
           <tx:method name="*" propagation="REQUIRED"rollback-for="java.lang.Exception"/>
          </tx:attributes>
   </tx:advice>

    <aop:config>
       <aop:pointcut id="interceptorPointCuts"
           expression="execution(* com.spring.service.*.*(..))" />
       
        <aop:pointcut id="leePointcut"
   expression="bean(mgrService) || bean(empService)" />
       <aop:advisor advice-ref="txAdvice"
           pointcut-ref="interceptorPointCuts"/>
       <aop:advisor advice-ref="txAdvice"
           pointcut-ref=" leePointcut"/>
   
      <aop:aspectid="authorityAspect" ref="authority">
         
         <aop:around pointcut="execution(*org.crazyjava.message.service.impl.*Impl.*Message*(..))"
            method="authority"/>
      </aop:aspect>
   </aop:config>

   <bean id="authority"
   class="org.crazyjava.message.authority.AuthorityInterceptor"/>

</beans>

关于权限拦截的类AuthorityInterceptor定义如下：
public class AuthorityInterceptor
{
   //进行权限检查的方法
    publicObject authority(ProceedingJoinPoint jp)
       throwsjava.lang.Throwable
    {
       HttpSessionsess = null;
      //获取被拦截方法的全部参数
       Object[]args = jp.getArgs();
      //遍历被拦截方法的全部参数
       for (int i =0 ; i < args.length ; i++ )
       {
         //找到HttpSession类型的参数
          if (args[i]instanceof HttpSession) sess =
            (HttpSession)args[i];
       }
      //取出HttpSession里的user属性
       IntegeruserId = (Integer)sess.getAttribute("user");
      //如果HttpSession里的user属性不为null，且大于0
       if ( userId!= null && userId >0)
       {
          //继续处理
          returnjp.proceed(args);
       }
       else
       {
         //如果还未登录，抛出异常
          throw newMessageException("您还没有登陆，请先登陆系统再执行该操作");
       }
    }
}

方式五、注解式声明事务（详见下篇博文）
其实他们还可以混合使用，方式三和方式四的混合使用：
<?xml version="1.0"encoding="UTF-8"?>
<beansxmlns="http://www.springframework.org/schema/beans"
   xmlns:aop="http://www.springframework.org/schema/aop"
   xmlns:tx="http://www.springframework.org/schema/tx"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-2.5.xsd
   http://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop-2.5.xsd
   http://www.springframework.org/schema/txhttp://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

    <bean id="exception"class="com.etc.advisor.ExceptionAdvisor"></bean>
   <bean id="tx"class="org.springframework.transaction.interceptor.TransactionInterceptor">
      <constructor-arg index="0">
         <ref bean="tm"/>
      </constructor-arg>
      <constructor-arg index="1">
         <props>
            <propkey="*">PROPAGATION_REQUIRED</prop>
         </props>
      </constructor-arg>
   </bean>

   <aop:configproxy-target-class="true">
      <aop:pointcut id="p1" expression="(execution(*com.etc.action.*.execute()))" />
      <aop:pointcut id="p2" expression="(execution(*com.etc.*.*.*(..)))" />
      <aop:pointcut id="p3" expression="(execution(*com.etc.service.*.*(..)))" />
      <aop:advisor advice-ref="tx"pointcut-ref="p1"/>
      <aop:advisor advice-ref="exception"pointcut-ref="p2"/>
   </aop:config>
</beans>

三、Spring事务配置示例
步骤一、配置文件(applicationContext.xml)：
   <?xml version="1.0"encoding="UTF-8"?>
<beansxmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

    <bean id="userservice"class="com.sunflower.yuan.serviceimp.UserServiceImp">
        <property name="jdbcTemplate">
            <ref bean="jdbcTemplate"/>
        </property>
    </bean>

    <bean id="datasource"class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName"value="com.mysql.jdbc.Driver"></property>
        <property name="url"value="jdbc:mysql://localhost:3306/mytest"></property>
        <property name="username"value="root"></property>
        <property name="password"value="root"></property>
    </bean>

    <bean id="transactionManager"class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource">
            <ref bean="datasource"/>
        </property>
    </bean>

    <bean id="jdbcTemplate"class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource">
            <ref bean="mydatasource"/>
        </property>
    </bean>



     <beanid="transactionAttributeSource"  class="org.springframework.transaction.interceptor.
        NameMatchTransactionAttributeSource">
        <property name="properties">
            <props>
                <prop key="getMoney">
                    PROPAGATION_REQUIRED,ISOLATION_DEFAULT,-NoMoneyException
                </prop>
            </props>
        </property>
    </bean>


    
    <beanid="userTransaction"
class="org.springframework.transaction.interceptor.  TransactionProxyFactoryBean">
        <propertyname="proxyInterfaces">
            <list>
                <value>com.sunflower.yuan.servicedao.UserService</value>
            </list>
        </property>
        <property name="target">
            <ref bean="userservice"/>
        </property>
        <propertyname="transactionManager">
            <ref bean="transactionManager"/>
        </property>
        <propertyname="transactionAttributeSource">
            <refbean="transactionAttributeSource"/>
        </property>
    </bean>
</beans>
声明式事务管理也是用动态代理模式来实现的，思想和AOP是一样的。主要是配置org.springframework.transaction.interceptor.TransactionProxyFactoryBean类。这个配置和AOP的配置非常相似。可以将事务属性单独写在org.springframework.transaction.interceptor.NameMatchTransactionAttributeSource中，然后再用<propertyname="transactionAttributeSource">引入，也可以直接用<propertyname="transactionAttributes">配置事务属性。
<propkey="getMoney">标签中的key="getMoney"表示对getMoney方法进行事务管理，也可使用通配符get*,表示对所有get前缀的方法进行事务管理。
事务属性的配置用","隔开，如下所示：

PROPAGATION, ISOLATION, readonly, -Exception, +Exception

PROPAGATION: 传播行为
ISOLATION:　隔离级别
readonly: 是否为只读事务(可选)
(+/-)Exception: 回滚规则。如果是"-"，遇到指定的Exception，事务回滚，如果是"+",事务不回滚。

UserService.java:
public interface UserService {
public void getMoney(int money, int id) throwsNoMoneyException;
}

UserServiceImp.java：
package com.sunflower.yuan.serviceimp;

import java.sql.ResultSet;
import java.sql.SQLException;

importorg.springframework.jdbc.core.JdbcTemplate;
importorg.springframework.jdbc.core.RowCallbackHandler;

importcom.sunflower.yuan.Exception.NoMoneyException;
importcom.sunflower.yuan.servicedao.UserService;

public class UserServiceImp implementsUserService {
    private JdbcTemplate jdbcTemplate;

    public JdbcTemplate getJdbcTemplate() {
        return jdbcTemplate;
    }

    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    @Override
    public void getMoney(int getMoney, int id) throws NoMoneyException{

        String sql = "select money from user where id=?";
        Object[] params = new Object[] { new Integer(id) };

        MyRowCallbackHandler rowCallBack = newMyRowCallbackHandler();
        jdbcTemplate.query(sql, params, rowCallBack);

        if (rowCallBack.getMoney() > getMoney) {
            sql = "update user set money=? where id=?";
            Object[] params2 = new Object[] {
                    rowCallBack.getMoney() - getMoney, new Integer(id) };
            jdbcTemplate.update(sql, params2);
            throw new NoMoneyException("余额不足");
        }

    }

    class MyRowCallbackHandler implements RowCallbackHandler {
        private int money = 0;

        public int getMoney() {
            return money;
        }

        public void setMoney(int money) {
            this.money = money;
        }

        @Override
        public void processRow(ResultSet rs) throws SQLException {
            this.money = rs.getInt("money");
        }
    }
}
这里要注意一点，要进行事务管理的方法，必须在方法外进行异常的抛出，这样事务管理器才能接收到，然后进行事务的回滚。如果用try-catch处理异常，将不会进行事务回滚。

Spring学习8-Spring事务管理（AOP/声明式式事务管理）相关推荐

Spring学习4-面向切面（AOP）之Spring接口方式
一.初识AOP 关于AOP的学习可以参看帮助文档:spring-3.2.0.M2\docs\reference\html目录下index.html的相关章节 1.AOP:Aspect ...
Spring 学习（三）大话AOP
一直想着怎么去通俗的讲解AOP,这两篇博客给了我启发 (https://blog.csdn.net/qukaiwei/article/details/50367761),(https://blog.c ...
spring学习12 -Spring 框架模块以及面试常见问题注解等
以下为spring常见面试问题: 1.Spring 框架中都用到了哪些设计模式? Spring框架中使用到了大量的设计模式,下面列举了比较有代表性的: 代理模式-在AOP和remoting中被用的比较 ...
【Spring学习】Spring简介
Spring 是一个开源框架,是为了解决企业应用程序开发复杂性而创建的.框架的主要优势之一就是其分层架构,分层架构允许您选择使用哪一个组件,同时为 J2EE 应用程序开发提供集成的框架. 一.Spri ...
【Spring学习】spring开发包介绍
spring.jar是包含有完整发布的单个jar包,spring.jar中包含除了 spring-mock.jar里所包含的内容外其它所有jar包的内容,因为只有在开发环境下才会用到spring-mo ...
Spring学习笔记--spring+mybatis集成
前言: 技术的发展, 真的是日新月异. 作为javaer, 都不约而同地抛弃裸写jdbc代码, 而用各种持久化框架. 从hibernate, Spring的JDBCTemplate, 到ibatis, ...
Spring 学习系列 -- Spring + Mybatis 从零开始配置多数据源访问
目的: 项目中以前有整合mybatis + spring操作数据库,但是以前都是单数据库,现需要实现mybatis访问多数据源,依旧使用spring调用mybatis. 通过注解的方式整合 sprin ...
【Spring学习】Spring自定义标签详细步骤
目录标题前言一.自定义标签步骤 1.定义属性POJO 2.定义XSD文件描述组件内容 3.定义标签解析器 4.注册标签解析器 5.定义spring.handlers和spring.schemas文 ...
Spring学习总结——Spring实现AOP的多种方式
目录一.基于XML配置的Spring AOP 二.使用注解配置AOP 三.AspectJ切点函数四.AspectJ通知注解五.零配置实现Spring IoC与AOP 六.示例下载 AOP(Asp ...

Spring学习8-Spring事务管理（AOP/声明式式事务管理）

Spring学习8-Spring事务管理（AOP/声明式式事务管理）相关推荐

最新文章

热门文章