Spring事务（三）：事务的隔离级别与传播方式的处理01

public enum Isolation {

    /**
    * Ĭֵø뼶ʹõݿõĸ뼶
    */
    DEFAULT(TransactionDefinition.ISOLATION_DEFAULT),

    /**
    * δύ
    */
    READ_UNCOMMITTED(TransactionDefinition.ISOLATION_READ_UNCOMMITTED),

    /**
    * ύ
    */
    READ_COMMITTED(TransactionDefinition.ISOLATION_READ_COMMITTED),

    /**
    * ظ
    */
    REPEATABLE_READ(TransactionDefinition.ISOLATION_REPEATABLE_READ),

    /**
    * л
    */
    SERIALIZABLE(TransactionDefinition.ISOLATION_SERIALIZABLE);

    ...
}

class A {
    // 
    @Transactional
    public void methdA() {
        // һЩ
        ...
    }
}

class B {
    // 
    @Transactional
    public void methodB() {
        // 1. һЩ
        ...
        // 2.  methodA()
        a.methodA();
        // 3. ﱨ
        throw new RuntimeException();
    }
}

public @interface Transactional {
    ...

    // ĬϵļΪ Propagation.REQUIRED
    Propagation propagation() default Propagation.REQUIRED;

}

@Configuration
@ComponentScan("org.springframework.learn.tx.demo03")
@EnableTransactionManagement(proxyTargetClass = true)
public class TxDemo03Config {

    /**
     * Դ
     */
    @Bean
    public DataSource dataSource() throws Exception {
        Driver driver = new com.mysql.jdbc.Driver();
        String url = "jdbc:mysql://localhost:3306/test";
        String username = "root";
        String password = "123";
        return new SimpleDriverDataSource(driver, url, username, password);
    }

    /**
     * jdbcTemplateݿIJ
     */
    @Bean
    public JdbcTemplate jdbcTemplate(DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }

    /**
     * 
     */
    @Bean
    public DataSourceTransactionManager transactionManager(DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }

}

@Service
public class UserService {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    /**
     * ݿʹ @Transactional 
     */
    @Transactional(rollbackFor = Exception.class)
    public int insert() {
        String sql = "insert into `user`(`login_name`, `nick`, `create_time`, `update_time`)" 
                + "values (?, ?, ?, ?)";
        int result = jdbcTemplate.update(sql, "test", "test", new Date(), new Date());
        if(true) {
            //throw new RuntimeException("׳쳣");
        }
        System.out.println(result);
        return result;
    }

}

public class TxDemo03Main {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext
                = new AnnotationConfigApplicationContext(TxDemo03Config.class);
        UserService userService = applicationContext.getBean(UserService.class);
        userService.insert();

    }
}

protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass,
        final InvocationCallback invocation) throws Throwable {
    TransactionAttributeSource tas = getTransactionAttributeSource();

    // 1. ȡ @Transactional 
    final TransactionAttribute txAttr = (tas != null 
            ? tas.getTransactionAttribute(method, targetClass) : null);

    // 2. ȡIOCлȡ
    final TransactionManager tm = determineTransactionManager(txAttr);

    // ⲿֵĴ TransactionManager  ReactiveTransactionManager 
    ...

    // 3.  TransactionManager תΪ PlatformTransactionManager
    PlatformTransactionManager ptm = asPlatformTransactionManager(tm);
    // 4. ȡȫ޶ʽΪ".."
    final String joinpointIdentification 
            = methodIdentification(method, targetClass, txAttr);
    if (txAttr == null || !(ptm instanceof CallbackPreferringPlatformTransactionManager)) {
        // 5. ȡϢ￪
        TransactionInfo txInfo = createTransactionIfNecessary(
                ptm, txAttr, joinpointIdentification);
        Object retVal;
        try {
            // 6. ִоҵ
            retVal = invocation.proceedWithInvocation();
        }
        catch (Throwable ex) {
            // 7. 쳣ع
            completeTransactionAfterThrowing(txInfo, ex);
            throw ex;
        }
        finally {
            // 8. ϢǽϢΪɵ
            cleanupTransactionInfo(txInfo);
        }

        if (vavrPresent && VavrDelegate.isVavrTry(retVal)) {
            TransactionStatus status = txInfo.getTransactionStatus();
            if (status != null && txAttr != null) {
                retVal = VavrDelegate.evaluateTryFailure(retVal, txAttr, status);
            }
        }
        // 9. ύ
        commitTransactionAfterReturning(txInfo);
        return retVal;
    }
    else {
        //  CallbackPreferringPlatformTransactionManager ͵ TransactionManager
        ...
    }
}

protected TransactionManager determineTransactionManager(@Nullable TransactionAttribute txAttr) {
    if (txAttr == null || this.beanFactory == null) {
        return getTransactionManager();
    }

    //  @Transaction עָʹspringлȡ
    String qualifier = txAttr.getQualifier();
    if (StringUtils.hasText(qualifier)) {
        return determineQualifiedTransactionManager(this.beanFactory, qualifier);
    }
    // ָƣҲǴspringлȡ
    else if (StringUtils.hasText(this.transactionManagerBeanName)) {
        return determineQualifiedTransactionManager(
            this.beanFactory, this.transactionManagerBeanName);
    }
    else {
        // ֱָӷ
        TransactionManager defaultTransactionManager = getTransactionManager();
        if (defaultTransactionManager == null) {
            // ӻлȡĬϵ
            defaultTransactionManager = this.transactionManagerCache
                    .get(DEFAULT_TRANSACTION_MANAGER_KEY);
            if (defaultTransactionManager == null) {
                // ʹ spring лȡһ
                defaultTransactionManager = this.beanFactory.getBean(TransactionManager.class);
                this.transactionManagerCache.putIfAbsent(
                        DEFAULT_TRANSACTION_MANAGER_KEY, defaultTransactionManager);
            }
        }
        return defaultTransactionManager;
    }
}

public DataSourceTransactionManager transactionManager(DataSource dataSource) {
    return new DataSourceTransactionManager(dataSource);
}

private PlatformTransactionManager asPlatformTransactionManager(
        @Nullable Object transactionManager) {
    if (transactionManager == null || transactionManager instanceof PlatformTransactionManager) {
        return (PlatformTransactionManager) transactionManager;
    } else {
        // ׸쳣
        ...
    }
}