《数据库原理及应用》第五章 数据库保护

  |   0 评论   |   1,213 浏览

    Spring提供的事务管理可以分为两类:编程式的和声明式的。编程式的,比较灵活,但是代码量大,存在重复的代码比较多;而声明式的比编程式的更灵活方便。本文将讨论这两种事务管理的区别。

    传统的JDBC事务管理

    以往使用JDBC进行数据操作时,一般采用DataSource,从数据源中得到Connection,我们知道数据源是线程安全的,而连接不是线程安全的,所以对每个请求都是从数据源中重新取出一个连接。一般的数据源由容器进行管理,包括连接池。例如TOMCAT,WEBSPHERE,WEBLOGIC等这些J2EE商业容器都提供了这个功能。

     以往的我们使用JDBC在写代码时,事务管理可能会是这样:

    Connection conn = null;
    Try
    {
     conn = DBConnectionFactory.getConnection;
     conn.setAutoCommit(false);
     //do something
     conn.commit(); //commit transaction
    } catch(Exception e) {
     conn.rollback();
     //do sth
    }Finally {
     Try
     {
        conn.close();
     }
      catch(SQLException se){ 
          //do sth.
      }
     //close ResultSet,PreparedStatement,Connection
     //notice:Maybe ocurr Exception when u close rs,pstmt,conn
    }

    按照以往的思路来写代码,代码量比较长,而且容易疏忽,忘掉一些try/catch,引发一些异常无法catch,虽然有时候我们会写DBTool类,来关闭这些资源,并且保证在关闭这些资源时,不向外抛异常。

    Spring提供的编程式的事务处理

    Spring提供了几个关于事务处理的类:

    •TransactionDefinition //事务属性定义

    •TranscationStatus //代表了当前的事务,可以提交,回滚。

    •PlatformTransactionManager这个是spring提供的用于管理事务的基础接口,其下有一个实现的抽象类AbstractPlatformTransactionManager,我们使用的事务管理类例如DataSourceTransactionManager等都是这个类的子类。

    我们使用编程式的事务管理流程可能如下:

    1 声明数据源

    2 声明一个事务管理类,例如DataSourceTransactionManager, HibernateTransactionManger, JTATransactionManager等

    3 在我们的代码中加入事务处理代码:

    TransactionDefinition td = new TransactionDefinition();
    TransactionStatus ts = transactionManager.getTransaction(td);
    Try
    {
     //do sth
     transactionManager.commit(ts);
    }
    catch(Exception e){
        transactionManager.rollback(ts);
    }

     使用spring提供的事务模板TransactionTemplate

    void add()
    {
     transactionTemplate.execute( 
        new TransactionCallback(){
             pulic Object doInTransaction(TransactionStatus ts)
      { //do sth}
     }
    }

    TransactionTemplate也是为我们省去了部分事务提交、回滚代码;定义事务模板时,需注入事务管理对象.

    Spring声明式事务处理

    Spring声明式事务处理也主要使用了ioc,aop思想,提供了TransactionInterceptor拦截器和常用的代理类TransactionProxyFactoryBean,可以直接对组件进行事务代理。

    使用TransactionInterceptor步骤

    1.定义数据源,事务管理类

    2.定义事务拦截器,such as:

    <bean id = "transactionInterceptor" 
         class="org.springframework.transaction.interceptor.TransactionInterceptor">
        <property name="transactionManager">
            <ref bean="transactionManager"/>
        </property>
        <property name="transactionAttributeSource">
            <value>
                com.test.UserManager.*r=PROPAGATION_REQUIRED
            </value>
        </property>
    </bean>

    3.为组件声明一个代理类:ProxyFactoryBean

    <bean id="userManager"
        class="org.springframework.aop.framework.ProxyFactoryBean">
       <property name="proxyInterfaces">
           <value>com.test.UserManager</value>
       </property>
       <property name="interceptorNames">
          <list>
            <idref local="transactionInterceptor"/>
          </list>
      </property>
    </bean>

     使用TransactionProxyFactoryBean:

    <bean id="userManager"
         class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
        <property name="transactionManager">
            <ref bean="transactionManager"/>
        </property>
        <property name="target">
            <ref local="userManagerTarget"/>
        </property>
        <property name="transactionAttributes">
        <props>
            <prop key="insert*">PROPAGATION_REQUIRED</prop>
            <prop key="update*">PROPAGATION_REQUIRED</prop>
            <prop key="*">PROPAGATION_REQUIRED,readOnly</prop>
        </props>
        </property>
    </bean>

    TransactionProxyFactoryBean只是为组件的事务代理,如果我们要给组件添加一些业务方面的验证等,可以使用TransactionTemplate加拦截器方式,为组件添加多个拦截器,spring AOP中提供了三类Advice,即前增强,后增强,抛出异常时的增强,可以灵活使用。

    >