Spring 源码：Transaction

try{
    // 获取连接
    conn = getConnection();
 
    // 设置: 不自动提交事务
    conn.setAutoCommit(false);
    Statement stmt = conn.createStatement();
    String SQL1 = “…";
    stmt.executeUpdate(SQL1);
    String SQL2 = “…";
    stmt.executeUpdate(SQL2);
 
    // 提交事务
    conn.commit();
}catch(SQLException se){
 
    //遇到异常时，回滚事务
    if(conn!=null)
        conn.rollback();
}finally{
 
    // 关闭连接
    try {
        if (con != null) con.close();
    } catch (SQLException ex) {
    }
}

public interface PlatformTransactionManager {
    //返回一个已经激活的事务或创建一个新的事务
    TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException;
    void commit(TransactionStatus status) throws TransactionException;
    void rollback(TransactionStatus status) throws TransactionException;
}

public class BankServiceImpl implements BankService {
     
    private BankDao bankDao;
    // 事务定义信息
    private TransactionDefinition txDefinition;
    // 事务管理器
    private PlatformTransactionManager txManager;
    ......
     
    // 完整的事务操作
    public boolean transfer(Long fromId， Long toId， double amount) {
         
        // 获取数据库连接: 包含事务状态.
        TransactionStatus txStatus = txManager.getTransaction(txDefinition);
        boolean result = false;
        try {
             
            // sql session 跟 事务管理器共用数据库连接
            result = bankDao.transfer(fromId， toId， amount);
             
            // 提交事务
            txManager.commit(txStatus);
             
        } catch (Exception e) {
             
            // 事务回滚
            result = false;
            txManager.rollback(txStatus);
            System.out.println("Transfer Error!");
        }
        return result;
    }
}

transactionTemplate.execute(new TransactionCallback() {
    public Object doInTransaction(TransactionStatus status) {
        try{
            // do xxx
        }
        catch (Exception e) {
            status.setRollbackOnly();  // 将事务标识为不可提交的
        }
    }
);

<!-- 使用JDBC事务管理器 -->
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> 
    <property name="dataSource" ref="dataSource" /> 
</bean>

<!-- 通过tx:advice 配置事务管理增强  -->
<tx:advice id="txAdvice" transaction-manager="txManager">
    <!-- 配置事务属性  -->
    <tx:attributes>
        <!-- 指定具体需要拦截的方法，对哪个方法用事务管理 -->
        <!-- 可以对要拦截的方法名使用通配符 -->
        <tx:method name="transfer" propagation="REQUIRED" isolation="DEFAULT" read-only="false" />
        <tx:method name="save*" propagation="REQUIRED" isolation="READ_COMMITTED"/> 
        <tx:method name="*" propagation="REQUIRED" isolation="READ_COMMITTED" read-only="true"/>
    </tx:attributes>
</tx:advice>
   
<!-- 配置AOP -->
<aop:config proxy-target-class="false">
    <!-- 配置切点 -->
    <aop:pointcut expression="execution(* service.MyService.*(..))" id="myTransactionPointcut"/>
    <!-- 对  myTransactionPointcut 切点 进行 txAdvice 增强 -->
    <aop:advisor advice-ref="txAdvice" pointcut-ref="myTransactionPointcut"/>
</aop:config>

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

@Transactional(propagation=Propagation.REQUIRED,isolation=Isolation.DEFAULT,rollbackFor=ArithmeticException.class)

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:mybatis="http://mybatis.org/schema/mybatis-spring"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:jdbc="http://www.springframework.org/schema/jdbc"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
                        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.1.xsd
                        http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-4.1.xsd
                        http://mybatis.org/schema/mybatis-spring http://mybatis.org/schema/mybatis-spring.xsd">
 
    <mybatis:scan base-package="com.meituan.movie.pro.dao.db" />
 
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="configLocation" value="classpath:mybatis-config.xml" />
        <property name="dataSource" ref="dataSource" />
    </bean>
 
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    </bean>
 
    <!-- 使用annotation定义事务 -->
    <tx:annotation-driven order="2" transaction-manager="transactionManager" proxy-target-class="true" />
 
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
        <!-- 基本属性 url、user、password -->
        <property name="url" value="${jdbc_url}" />
        <property name="username" value="${jdbc_username}" />
        <property name="password" ref="dbPassword" />
        <property name="driverClassName" value="${jdbc_driverClassName}" />
 
        <!-- 配置初始化大小、最小、最大 -->
        <property name="initialSize" value="${jdbc_initialSize}" />
        <property name="minIdle" value="${jdbc_minIdle}" />
        <property name="maxActive" value="${jdbc_maxActive}" />
 
        <!-- 配置获取连接等待超时的时间 -->
        <property name="maxWait" value="${jdbc_maxWait}" />
 
        <!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->
        <property name="timeBetweenEvictionRunsMillis" value="${jdbc_timeBetweenEvictionRunsMillis}" />
 
        <!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->
        <property name="minEvictableIdleTimeMillis" value="${jdbc_minEvictableIdleTimeMillis}" />
 
        <property name="testWhileIdle" value="${jdbc_testWhileIdle}" />
        <property name="testOnBorrow" value="${jdbc_testOnBorrow}" />
        <property name="validationQuery" value="${jdbc_validationQuery}" />
        <property name="connectionInitSqls" value="${jdbc_connectionInitSqls}" />
    </bean>
 
</beans>

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