Spring事务实现分析

　　<bean id="baseDataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close"

          abstract="true">

        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>

        <property name="initialSize" value="2"/>

        <property name="minIdle" value="2"/>

        <property name="maxActive" value="20"/>

        <property name="maxWait" value="10000"/>

        <property name="timeBetweenEvictionRunsMillis" value="60000"/>

        <property name="minEvictableIdleTimeMillis" value="300000"/>

        <property name="validationQuery" value="SELECT 'x' FROM DUAL"/>

        <property name="testWhileIdle" value="true"/>

        <property name="testOnBorrow" value="false"/>

        <property name="testOnReturn" value="false"/>

        <property name="filters" value="stat"/>

    </bean>

    <!-- 搜索系统数据源 -->

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close"

          parent="baseDataSource">

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

        <property name="username" value="${jdbc.user.search}"/>

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

    </bean>

　　

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

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

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

　　</bean>

　　<!-- 使得事务注解生效 -->

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

　　@Transactional

    public void updatePoiRank(PoiRank rank) {

        poiRankDAO.updatePoiRank(rank);

    }

public void testTransaction() {

    db.update("insert into z1(c1) values('2')"); //执行成功

    // 主动抛出异常 测试回滚

    String str = null;

    if (str.startsWith("111")) {  // 空指针异常

        db.update("insert into z2(c1,c2) values('2','3')"); //执行失败

    }

}

@Transactional

public void testTransaction() {

    db.update("insert into z1(c1) values('2')");

    // 主动抛出异常 测试回滚

    String str = null;

    if (str.startsWith("111")) {        // 空指针异常

        db.update("insert into z2(c1,c2) values('2','3')");

    }

}

@Transactional

public void testTransaction() {

    db.update("insert into z1(c1) values('2')");

    String str = "111";

    if (str.startsWith("111")) {

        db.update("insert into z2(c1,c2) values('2','3')");

    }

}

@Transactional

public void testTransaction() {

    db.update("insert into z1(c1) values('2')");

    testTransaction2();

}

public void testTransaction2() {

    // 主动抛出异常 测试回滚

    String str = null;

    if (str.startsWith("111")) {

        db.update("insert into z2(c1,c2) values('2','3')");

    }

}

public void testTransaction() {

    testTransaction3();

}

@Transactional

public void testTransaction3() {

    db.update("insert into z1(c1) values('2')");

    // 测试

    String str = null;

    if (str.startsWith("111")) {

        db.update("insert into z1(c1) values('adff2')");

    }

}

　　@Transactional(rollbackFor=Exception.class) 

　　<tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true"/>

　　<context:component-scan base-package="org.test" ></context:component-scan>

　　http\://www.springframework.org/schema/tx=org.springframework.transaction.config.TxNamespaceHandler

　　public void init() {

        this.registerBeanDefinitionParser("advice", new TxAdviceBeanDefinitionParser());

        this.registerBeanDefinitionParser("annotation-driven", new AnnotationDrivenBeanDefinitionParser());

        this.registerBeanDefinitionParser("jta-transaction-manager", new JtaTransactionManagerBeanDefinitionParser());

    }

public BeanDefinition parse(Element element, ParserContext parserContext) {

    // 注册事务相关的监听器，如果某个方法标注了TransactionalEventListener注解，

    // 那么该方法就是一个事务事件触发方法，即发生某种事务事件后，将会根据该注解的设置，回调指定类型的方法。常见的事务事件有：事务执行前和事务完成(包括报错后的完成)后的事件。

    registerTransactionalEventListenerFactory(parserContext);

    String mode = element.getAttribute("mode");

    // 获取当前事务驱动程序的模式，如果使用了aspectj模式，则会注册一个AnnotationTransactionAspect类型的bean，用户可以以aspectj的方式使用该bean对事务进行更多的配置

    if ("aspectj".equals(mode)) {

        registerTransactionAspect(element, parserContext);

    } else {

        // 一般使用的是当前这种方式，这种方式将会在Spring中注册三个bean，分别是

        // AnnotationTransactionAttributeSource，TransactionInterceptor和BeanFactoryTransactionAttributeSourceAdvisor，并通过Aop的方式实现事务

        AopAutoProxyConfigurer.configureAutoProxyCreator(element, parserContext);

    }

    return null;

}

public static void configureAutoProxyCreator(Element element, ParserContext parserContext) {

    // 这个方法主要是在当前BeanFactory中注册InfrastructureAdvisorAutoProxyCreator这个

    // bean，这个bean继承了AbstractAdvisorAutoProxyCreator，也就是其实现原理与我们前面

    // 讲解的Spring Aop的实现原理几乎一致

    AopNamespaceUtils.registerAutoProxyCreatorIfNecessary(parserContext, element);

    // 这里的txAdvisorBeanName就是我们最终要注册的bean，其类型就是下面注册的

    // BeanFactoryTransactionAttributeSourceAdvisor，可以看到，其本质是一个

    // Advisor类型的对象，因而Spring Aop会将其作为一个切面织入到指定的bean中

    String txAdvisorBeanName = TransactionManagementConfigUtils

        .TRANSACTION_ADVISOR_BEAN_NAME;

    // 如果当前BeanFactory中已经存在了目标bean，则不进行注册

    if (!parserContext.getRegistry().containsBeanDefinition(txAdvisorBeanName)) {

        Object eleSource = parserContext.extractSource(element);

        // 注册AnnotationTransactionAttributeSource，这个bean的主要作用是封装

        // @Transactional注解中声明的各个属性

        RootBeanDefinition sourceDef = new RootBeanDefinition(

       "org.springframework.transaction.annotation.AnnotationTransactionAttributeSource");

        sourceDef.setSource(eleSource);

        sourceDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);

        String sourceName = parserContext.getReaderContext()

            .registerWithGeneratedName(sourceDef);

        // 注册TransactionInterceptor类型的bean，并且将上面的封装属性的bean设置为其一个属性。

        // 这个bean本质上是一个Advice(可查看其继承结构)，Spring Aop使用Advisor封装实现切面

        // 逻辑织入所需的所有属性，但真正的切面逻辑却是保存在其Advice属性中的，也就是说这里的

        // TransactionInterceptor才是真正封装了事务切面逻辑的bean

        RootBeanDefinition interceptorDef =

            new RootBeanDefinition(TransactionInterceptor.class);

        interceptorDef.setSource(eleSource);

        interceptorDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);

        registerTransactionManager(element, interceptorDef);

        interceptorDef.getPropertyValues().add("transactionAttributeSource",

            new RuntimeBeanReference(sourceName));

        String interceptorName = parserContext.getReaderContext()

            .registerWithGeneratedName(interceptorDef);

        // 注册BeanFactoryTransactionAttributeSourceAdvisor类型的bean，这个bean实现了

        // Advisor接口，实际上就是封装了当前需要织入的切面的所有所需的属性

        RootBeanDefinition advisorDef =

            new RootBeanDefinition(BeanFactoryTransactionAttributeSourceAdvisor.class);

        advisorDef.setSource(eleSource);

        advisorDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);

        advisorDef.getPropertyValues().add("transactionAttributeSource",

            new RuntimeBeanReference(sourceName));

        advisorDef.getPropertyValues().add("adviceBeanName", interceptorName);

        if (element.hasAttribute("order")) {

            advisorDef.getPropertyValues().add("order", element.getAttribute("order"));

        }

        parserContext.getRegistry().registerBeanDefinition(txAdvisorBeanName, advisorDef);

        // 将需要注册的bean封装到CompositeComponentDefinition中，并且进行注册

        CompositeComponentDefinition compositeDef =

            new CompositeComponentDefinition(element.getTagName(), eleSource);

        compositeDef.addNestedComponent(

            new BeanComponentDefinition(sourceDef, sourceName));

        compositeDef.addNestedComponent(

            new BeanComponentDefinition(interceptorDef, interceptorName));

        compositeDef.addNestedComponent(

            new BeanComponentDefinition(advisorDef, txAdvisorBeanName));

        parserContext.registerComponent(compositeDef);

    }

}