【源码解析】Spring事务 @Transactional 源码解析

最新推荐文章于 2024-04-17 15:31:54 发布
最新推荐文章于 2024-04-17 15:31:54 发布
阅读量743 收藏 1
点赞数
分类专栏： 源码解析 文章标签： spring java spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42985872/article/details/130301056
版权

源码解析

自动化配置

在spring-boot-autoconfigure查看spring.factories引入TransactionAutoConfiguration

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration,\

查看TransactionAutoConfiguration源码发现包含注解@EnableTransactionManagement

    @Configuration(
        proxyBeanMethods = false
    )
    @ConditionalOnBean({TransactionManager.class})
    @ConditionalOnMissingBean({AbstractTransactionManagementConfiguration.class})
    public static class EnableTransactionManagementConfiguration {
        public EnableTransactionManagementConfiguration() {
        }

        @Configuration(
            proxyBeanMethods = false
        )
        @EnableTransactionManagement(
            proxyTargetClass = true
        )
        @ConditionalOnProperty(
            prefix = "spring.aop",
            name = {"proxy-target-class"},
            havingValue = "true",
            matchIfMissing = true
        )
        public static class CglibAutoProxyConfiguration {
            public CglibAutoProxyConfiguration() {
            }
        }

        @Configuration(
            proxyBeanMethods = false
        )
        @EnableTransactionManagement(
            proxyTargetClass = false
        )
        @ConditionalOnProperty(
            prefix = "spring.aop",
            name = {"proxy-target-class"},
            havingValue = "false",
            matchIfMissing = false
        )
        public static class JdkDynamicAutoProxyConfiguration {
            public JdkDynamicAutoProxyConfiguration() {
            }
        }
    }

查看@EnableTransactionManagement源码，发现TransactionManagementConfigurationSelector

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import({TransactionManagementConfigurationSelector.class})
public @interface EnableTransactionManagement {
    boolean proxyTargetClass() default false;

    AdviceMode mode() default AdviceMode.PROXY;

    int order() default 2147483647;
}

查看TransactionManagementConfigurationSelector，引入了ProxyTransactionManagementConfiguration

public class TransactionManagementConfigurationSelector extends AdviceModeImportSelector<EnableTransactionManagement> {
    public TransactionManagementConfigurationSelector() {
    }

    protected String[] selectImports(AdviceMode adviceMode) {
        switch(adviceMode) {
        case PROXY:
            return new String[]{AutoProxyRegistrar.class.getName(), ProxyTransactionManagementConfiguration.class.getName()};
        case ASPECTJ:
            return new String[]{this.determineTransactionAspectClass()};
        default:
            return null;
        }
    }

    private String determineTransactionAspectClass() {
        return ClassUtils.isPresent("javax.transaction.Transactional", this.getClass().getClassLoader()) ? "org.springframework.transaction.aspectj.AspectJJtaTransactionManagementConfiguration" : "org.springframework.transaction.aspectj.AspectJTransactionManagementConfiguration";
    }
}

切面和拦截器

ProxyTransactionManagementConfiguration往容器中注入BeanFactoryTransactionAttributeSourceAdvisor，切面是TransactionAttributeSource，拦截器是TransactionInterceptor

@Configuration(
    proxyBeanMethods = false
)
@Role(2)
public class ProxyTransactionManagementConfiguration extends AbstractTransactionManagementConfiguration {
    public ProxyTransactionManagementConfiguration() {
    }

    @Bean(
        name = {"org.springframework.transaction.config.internalTransactionAdvisor"}
    )
    @Role(2)
    public BeanFactoryTransactionAttributeSourceAdvisor transactionAdvisor(TransactionAttributeSource transactionAttributeSource, TransactionInterceptor transactionInterceptor) {
        BeanFactoryTransactionAttributeSourceAdvisor advisor = new BeanFactoryTransactionAttributeSourceAdvisor();
        advisor.setTransactionAttributeSource(transactionAttributeSource);
        advisor.setAdvice(transactionInterceptor);
        if (this.enableTx != null) {
            advisor.setOrder((Integer)this.enableTx.getNumber("order"));
        }

        return advisor;
    }

    @Bean
    @Role(2)
    public TransactionAttributeSource transactionAttributeSource() {
        return new AnnotationTransactionAttributeSource();
    }

    @Bean
    @Role(2)
    public TransactionInterceptor transactionInterceptor(TransactionAttributeSource transactionAttributeSource) {
        TransactionInterceptor interceptor = new TransactionInterceptor();
        interceptor.setTransactionAttributeSource(transactionAttributeSource);
        if (this.txManager != null) {
            interceptor.setTransactionManager(this.txManager);
        }

        return interceptor;
    }
}

判断类是否需要被事务拦截。

AnnotationTransactionAttributeSource#isCandidateClass，判断是候选类

    public boolean isCandidateClass(Class<?> targetClass) {
        Iterator var2 = this.annotationParsers.iterator();

        TransactionAnnotationParser parser;
        do {
            if (!var2.hasNext()) {
                return false;
            }

            parser = (TransactionAnnotationParser)var2.next();
        } while(!parser.isCandidateClass(targetClass));

        return true;
    }

SpringTransactionAnnotationParser#isCandidateClass

    public boolean isCandidateClass(Class<?> targetClass) {
        return AnnotationUtils.isCandidateClass(targetClass, Transactional.class);
    }

拦截器的具体逻辑

拦截器TransactionInterceptor，执行TransactionInterceptor#invoke方法。

    @Nullable
    public Object invoke(MethodInvocation invocation) throws Throwable {
        Class<?> targetClass = invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null;
        Method var10001 = invocation.getMethod();
        invocation.getClass();
        return this.invokeWithinTransaction(var10001, targetClass, invocation::proceed);
    }

TransactionAspectSupport#invokeWithinTransaction，具体的事务处理逻辑。

  1. createTransactionIfNecessary。创建事务，包含数据库的连接和事务状态等信息；

  2. completeTransactionAfterThrowing。调用目标方法报错，回滚；

  3. commitTransactionAfterReturning。调用目标方法成功，提交事务（里面有一些判断，不符合条件可能会回滚）

    @Nullable
    protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass, TransactionAspectSupport.InvocationCallback invocation) throws Throwable {
        TransactionAttributeSource tas = this.getTransactionAttributeSource();
        TransactionAttribute txAttr = tas != null ? tas.getTransactionAttribute(method, targetClass) : null;
        TransactionManager tm = this.determineTransactionManager(txAttr);
        if (this.reactiveAdapterRegistry != null && tm instanceof ReactiveTransactionManager) {
            // ... 
        } else {
            PlatformTransactionManager ptm = this.asPlatformTransactionManager(tm);
            String joinpointIdentification = this.methodIdentification(method, targetClass, txAttr);
            Object retVal;
            // ...
            } else {
                TransactionAspectSupport.TransactionInfo txInfo = this.createTransactionIfNecessary(ptm, txAttr, joinpointIdentification);

                try {
                    retVal = invocation.proceedWithInvocation();
                } catch (Throwable var18) {
                    this.completeTransactionAfterThrowing(txInfo, var18);
                    throw var18;
                } finally {
                    this.cleanupTransactionInfo(txInfo);
                }

                if (vavrPresent && TransactionAspectSupport.VavrDelegate.isVavrTry(retVal)) {
                    TransactionStatus status = txInfo.getTransactionStatus();
                    if (status != null && txAttr != null) {
                        retVal = TransactionAspectSupport.VavrDelegate.evaluateTryFailure(retVal, txAttr, status);
                    }
                }

                this.commitTransactionAfterReturning(txInfo);
                return retVal;
            }
        }
    }

获取事务

TransactionAspectSupport#createTransactionIfNecessary，创建事务

    protected TransactionAspectSupport.TransactionInfo createTransactionIfNecessary(@Nullable PlatformTransactionManager tm, @Nullable TransactionAttribute txAttr, final String joinpointIdentification) {
        if (txAttr != null && ((TransactionAttribute)txAttr).getName() == null) {
            txAttr = new DelegatingTransactionAttribute((TransactionAttribute)txAttr) {
                public String getName() {
                    return joinpointIdentification;
                }
            };
        }

        TransactionStatus status = null;
        if (txAttr != null) {
            if (tm != null) {
                status = tm.getTransaction((TransactionDefinition)txAttr);
            } else if (this.logger.isDebugEnabled()) {
                this.logger.debug("Skipping transactional joinpoint [" + joinpointIdentification + "] because no transaction manager has been configured");
            }
        }

        return this.prepareTransactionInfo(tm, (TransactionAttribute)txAttr, joinpointIdentification, status);
    }

AbstractPlatformTransactionManager#getTransaction，获取事务。

    public final TransactionStatus getTransaction(@Nullable TransactionDefinition definition) throws TransactionException {
        TransactionDefinition def = definition != null ? definition : TransactionDefinition.withDefaults();
        Object transaction = this.doGetTransaction();
        boolean debugEnabled = this.logger.isDebugEnabled();
        if (this.isExistingTransaction(transaction)) {
            return this.handleExistingTransaction(def, transaction, debugEnabled);
        } else if (def.getTimeout() < -1) {
            throw new InvalidTimeoutException("Invalid transaction timeout", def.getTimeout());
        } else if (def.getPropagationBehavior() == 2) {
            throw new IllegalTransactionStateException("No existing transaction found for transaction marked with propagation 'mandatory'");
        } else if (def.getPropagationBehavior() != 0 && def.getPropagationBehavior() != 3 && def.getPropagationBehavior() != 6) {
            if (def.getIsolationLevel() != -1 && this.logger.isWarnEnabled()) {
                this.logger.warn("Custom isolation level specified but no actual transaction initiated; isolation level will effectively be ignored: " + def);
            }

            boolean newSynchronization = this.getTransactionSynchronization() == 0;
            return this.prepareTransactionStatus(def, (Object)null, true, newSynchronization, debugEnabled, (Object)null);
        } else {
            AbstractPlatformTransactionManager.SuspendedResourcesHolder suspendedResources = this.suspend((Object)null);
            if (debugEnabled) {
                this.logger.debug("Creating new transaction with name [" + def.getName() + "]: " + def);
            }

            try {
                return this.startTransaction(def, transaction, debugEnabled, suspendedResources);
            } catch (Error | RuntimeException var7) {
                this.resume((Object)null, suspendedResources);
                throw var7;
            }
        }
    }

    private TransactionStatus startTransaction(TransactionDefinition definition, Object transaction, boolean debugEnabled, @Nullable AbstractPlatformTransactionManager.SuspendedResourcesHolder suspendedResources) {
        boolean newSynchronization = this.getTransactionSynchronization() != 2;
        DefaultTransactionStatus status = this.newTransactionStatus(definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
        this.doBegin(transaction, definition);
        this.prepareSynchronization(status, definition);
        return status;
    }

DataSourceTransactionManager#doBegin，事务管理器开启连接，设置未提交。判断事务是新的，则将资源绑定到TransactionSynchronizationManager

    protected void doBegin(Object transaction, TransactionDefinition definition) {
        DataSourceTransactionManager.DataSourceTransactionObject txObject = (DataSourceTransactionManager.DataSourceTransactionObject)transaction;
        Connection con = null;

        try {
            if (!txObject.hasConnectionHolder() || txObject.getConnectionHolder().isSynchronizedWithTransaction()) {
                Connection newCon = this.obtainDataSource().getConnection();
                if (this.logger.isDebugEnabled()) {
                    this.logger.debug("Acquired Connection [" + newCon + "] for JDBC transaction");
                }

                txObject.setConnectionHolder(new ConnectionHolder(newCon), true);
            }

            txObject.getConnectionHolder().setSynchronizedWithTransaction(true);
            con = txObject.getConnectionHolder().getConnection();
            Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);
            txObject.setPreviousIsolationLevel(previousIsolationLevel);
            txObject.setReadOnly(definition.isReadOnly());
            if (con.getAutoCommit()) {
                txObject.setMustRestoreAutoCommit(true);
                if (this.logger.isDebugEnabled()) {
                    this.logger.debug("Switching JDBC Connection [" + con + "] to manual commit");
                }

                con.setAutoCommit(false);
            }

            this.prepareTransactionalConnection(con, definition);
            txObject.getConnectionHolder().setTransactionActive(true);
            int timeout = this.determineTimeout(definition);
            if (timeout != -1) {
                txObject.getConnectionHolder().setTimeoutInSeconds(timeout);
            }

            if (txObject.isNewConnectionHolder()) {
                TransactionSynchronizationManager.bindResource(this.obtainDataSource(), txObject.getConnectionHolder());
            }

        } catch (Throwable var7) {
            if (txObject.isNewConnectionHolder()) {
                DataSourceUtils.releaseConnection(con, this.obtainDataSource());
                txObject.setConnectionHolder((ConnectionHolder)null, false);
            }

            throw new CannotCreateTransactionException("Could not open JDBC Connection for transaction", var7);
        }
    }

事务的数据库连接信息将保存到TransactionSynchronizationManager

    private static final ThreadLocal<Map<Object, Object>> resources = new NamedThreadLocal("Transactional resources");
    
	public static void bindResource(Object key, Object value) throws IllegalStateException {
        Object actualKey = TransactionSynchronizationUtils.unwrapResourceIfNecessary(key);
        Assert.notNull(value, "Value must not be null");
        Map<Object, Object> map = (Map)resources.get();
        if (map == null) {
            map = new HashMap();
            resources.set(map);
        }

        Object oldValue = ((Map)map).put(actualKey, value);
        if (oldValue instanceof ResourceHolder && ((ResourceHolder)oldValue).isVoid()) {
            oldValue = null;
        }

        if (oldValue != null) {
            throw new IllegalStateException("Already value [" + oldValue + "] for key [" + actualKey + "] bound to thread [" + Thread.currentThread().getName() + "]");
        } else {
            if (logger.isTraceEnabled()) {
                logger.trace("Bound value [" + value + "] for key [" + actualKey + "] to thread [" + Thread.currentThread().getName() + "]");
            }

        }
    }

事务回滚

TransactionAspectSupport#completeTransactionAfterThrowing

    protected void completeTransactionAfterThrowing(@Nullable TransactionAspectSupport.TransactionInfo txInfo, Throwable ex) {
        if (txInfo != null && txInfo.getTransactionStatus() != null) {
            if (this.logger.isTraceEnabled()) {
                this.logger.trace("Completing transaction for [" + txInfo.getJoinpointIdentification() + "] after exception: " + ex);
            }

            if (txInfo.transactionAttribute != null && txInfo.transactionAttribute.rollbackOn(ex)) {
                try {
                    txInfo.getTransactionManager().rollback(txInfo.getTransactionStatus());
                } catch (TransactionSystemException var6) {
                    this.logger.error("Application exception overridden by rollback exception", ex);
                    var6.initApplicationException(ex);
                    throw var6;
                } catch (Error | RuntimeException var7) {
                    this.logger.error("Application exception overridden by rollback exception", ex);
                    throw var7;
                }
            } else {
                try {
                    txInfo.getTransactionManager().commit(txInfo.getTransactionStatus());
                } catch (TransactionSystemException var4) {
                    this.logger.error("Application exception overridden by commit exception", ex);
                    var4.initApplicationException(ex);
                    throw var4;
                } catch (Error | RuntimeException var5) {
                    this.logger.error("Application exception overridden by commit exception", ex);
                    throw var5;
                }
            }
        }

    }

AbstractPlatformTransactionManager#rollback

    public final void rollback(TransactionStatus status) throws TransactionException {
        if (status.isCompleted()) {
            throw new IllegalTransactionStateException("Transaction is already completed - do not call commit or rollback more than once per transaction");
        } else {
            DefaultTransactionStatus defStatus = (DefaultTransactionStatus)status;
            this.processRollback(defStatus, false);
        }
    }

DataSourceTransactionManager#doRollback，调用到Connection的回滚方法

    protected void doRollback(DefaultTransactionStatus status) {
        DataSourceTransactionManager.DataSourceTransactionObject txObject = (DataSourceTransactionManager.DataSourceTransactionObject)status.getTransaction();
        Connection con = txObject.getConnectionHolder().getConnection();
        if (status.isDebug()) {
            this.logger.debug("Rolling back JDBC transaction on Connection [" + con + "]");
        }

        try {
            con.rollback();
        } catch (SQLException var5) {
            throw new TransactionSystemException("Could not roll back JDBC transaction", var5);
        }
    }

事务提交

TransactionAspectSupport#commitTransactionAfterReturning，进行事务提交

    protected void commitTransactionAfterReturning(@Nullable TransactionAspectSupport.TransactionInfo txInfo) {
        if (txInfo != null && txInfo.getTransactionStatus() != null) {
            if (this.logger.isTraceEnabled()) {
                this.logger.trace("Completing transaction for [" + txInfo.getJoinpointIdentification() + "]");
            }

            txInfo.getTransactionManager().commit(txInfo.getTransactionStatus());
        }

    }

获取连接

SpringManagedTransaction#getConnection

    public Connection getConnection() throws SQLException {
        if (this.connection == null) {
            this.openConnection();
        }

        return this.connection;
    }

    private void openConnection() throws SQLException {
        this.connection = DataSourceUtils.getConnection(this.dataSource);
        this.autoCommit = this.connection.getAutoCommit();
        this.isConnectionTransactional = DataSourceUtils.isConnectionTransactional(this.connection, this.dataSource);
        LOGGER.debug(() -> {
            return "JDBC Connection [" + this.connection + "] will" + (this.isConnectionTransactional ? " " : " not ") + "be managed by Spring";
        });
    }

DataSourceUtils#getConnection，获取连接，是从TransactionSynchronizationManager获取的，用到了线程变量。

    public static Connection getConnection(DataSource dataSource) throws CannotGetJdbcConnectionException {
        try {
            return doGetConnection(dataSource);
        } catch (SQLException var2) {
            throw new CannotGetJdbcConnectionException("Failed to obtain JDBC Connection", var2);
        } catch (IllegalStateException var3) {
            throw new CannotGetJdbcConnectionException("Failed to obtain JDBC Connection: " + var3.getMessage());
        }
    }

    public static Connection doGetConnection(DataSource dataSource) throws SQLException {
        Assert.notNull(dataSource, "No DataSource specified");
        ConnectionHolder conHolder = (ConnectionHolder)TransactionSynchronizationManager.getResource(dataSource);
        if (conHolder == null || !conHolder.hasConnection() && !conHolder.isSynchronizedWithTransaction()) {
            logger.debug("Fetching JDBC Connection from DataSource");
            Connection con = fetchConnection(dataSource);
            if (TransactionSynchronizationManager.isSynchronizationActive()) {
                try {
                    ConnectionHolder holderToUse = conHolder;
                    if (conHolder == null) {
                        holderToUse = new ConnectionHolder(con);
                    } else {
                        conHolder.setConnection(con);
                    }

                    holderToUse.requested();
                    TransactionSynchronizationManager.registerSynchronization(new DataSourceUtils.ConnectionSynchronization(holderToUse, dataSource));
                    holderToUse.setSynchronizedWithTransaction(true);
                    if (holderToUse != conHolder) {
                        TransactionSynchronizationManager.bindResource(dataSource, holderToUse);
                    }
                } catch (RuntimeException var4) {
                    releaseConnection(con, dataSource);
                    throw var4;
                }
            }

            return con;
        } else {
            conHolder.requested();
            if (!conHolder.hasConnection()) {
                logger.debug("Fetching resumed JDBC Connection from DataSource");
                conHolder.setConnection(fetchConnection(dataSource));
            }

            return conHolder.getConnection();
        }
    }

在这里插入图片描述

秋装什么
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
浅谈Spring中@Transactional事务回滚及示例（附源码）
08-28
本篇文章主要介绍了浅谈Spring中@Transactional事务回滚及示例（附源码），小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
@Transactional源码解析（一）
Sterne_的博客
07-28 431
如果希望使用自定义的TransactionManager，可以手动创建一个实现了接口的事务管理器，并将其配置为Spring Boot的一个bean。// 主要就是继承AbstractPlatformTransactionManager实现相关接口 }作者目前还没有遇到需要自定义事务管理器的场景所以无法给出示例。
Spring系列第48篇：@Transaction 事务源码解析
最新发布
2301_76267999的博客
04-17 970
2020年在匆匆忙忙慌慌乱乱中就这么度过了，我们迎来了新一年，互联网的发展如此之快，技术日新月异，更新迭代成为了这个时代的代名词，坚持下来的技术体系会越来越健壮，JVM作为如今是跳槽大厂必备的技能，如果你还没掌握，更别提之后更新的新技术了。更多JVM面试整理：《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！[外链图片转存中…(img-kfEl9QYG-1713339102796)]
Spring之@Transactional核心源码解读
lilimiki的博客
02-15 855
在基于Spring框架的程序中我们一般会使用Spring提供的事务管理器对事务进行管理。Spring支持编程式事务以及声明式事务，声明式事务使用@Transactional注解标志方法，表示开启事务，使用注解较为简洁、方便，也是Spring中较常用的开启事务的方式，为了能灵活使用@Transactional注解，有必要对该注解的实现深入了解。
Spring之@Transactional源码解析
qq_38257958的博客
03-05 1173
我们在日常开发的时候经常会用到组合注解,比如:@EnableTransactionManagement + @Transactional、@EnableAsync + @Async、@EnableAspectJAutoProxy + @Aspect。今天我们就来抽丝剥茧,揭开@Transactional注解的神秘面纱BeanPostProcessor从本质上说，它也是一个bean，不过它优先实例化，然后作用于普通bean。
@Transactional 源码解析
山巅
04-12 3416
@Transactional 源码解析1.springboot 下@Transactional使用方式2.spring是怎么处理事务的2.1三级目录 1.springboot 下@Transactional使用方式 在springboot框架下，事务管理只要在实现类方法上增加@Transactional这个注解就可以了。 @Transactional @Override public int insertMapiInterfaceCallConfig(InterfaceCallCo
Spring——事务注解@Transactional的源码分析
娜娜米的博客
07-17 3017
​ 本篇结合我的这篇《Spring事务注解@Transactional》，为第二节【2.Spring声明式事务的原理】的详细说明，debug了被@Transactional包裹的目标方法所在类的Bean实例初始化过程，包括：如何判断生成代理对象流程及如何定义代理对象的回调逻辑；...........................
Spring 之 @Transactional 注解简单使用及源码分析
龚小帅的博客
01-10 1230
但是这段逻辑是一个模版模式，也就是一段公共逻辑，所以是在抽象类中写的。因为类是一个抽象类，不可能被实例化的，那么如何会调用到这段逻辑呢？肯定需要去找这个抽象类的子类，所以类就去实现类。所以可以看出注解只是引入一个入口类，在这里入口类中并没有做什么逻辑，有用逻辑都是在它父类中完成。/** 合适的通知不为空 */ if(specificInterceptors!方法会去收集当前 bean 有哪些 Advisor 可以对其增强。如果找到有 Advisor 可以对其增强，就会调用方法为其创建代理对象。
@Transactional 事务获取数据源的源码解析
nandao158的博客
12-09 1399
@Transactional 事务获取数据源的源码解析
@Transactional的用法详解及Transactional事务无效的源码分析
阿尔法小师妹
07-02 1517
数据库事务正确执行的四要素 1.原子性 事务是不可分割的最小的工作单元，事务内的操作要么全做，要么全不做，不能只做一部分。 2.一致性 事务执行前数据库的数据按照逻辑处于正确的状态，事务执行后数据库的数据按照逻辑也处于正确状态。如果事务执行前后不是逻辑应该的正确状态，那么数据是不一致的。 3.隔离性 在并发事务的条件下，事务之间互不影响，即一个事务的内部操作对其他事务不影响，需要设...
Spring源码剖析-Transactional 事务执行流程
墨家巨子@俏如来
07-05 1548
前言 上一篇《Transactional源码解析》我们介绍了Spring对Transactional的解析，也就是事务的初始化工作，这一篇我们接着来分析事务的执行流程。 事务拦截器：TransactionInterceptor TransactionInterceptor是事务拦截器，该类实现了TransactionAspectSupport ， TransactionAspectSupport 中持有 TransactionManager ,拥有处理事务的能力。同时该类还实现了 MethodInterce
Spring @Transactional工作原理详解
08-28
主要介绍了Spring @Transactional工作原理详解，具有一定借鉴价值，需要的朋友可以参考下。
Spring声明式事务@Transactional知识点分享
08-25
在本篇文章里小编给大家整理了关于Spring声明式事务@Transactional详解内容，需要的朋友们可以参考下。
【Spring源码解析】事务流程解析
12-22
以方法为单位，进行事务控制；抛出异常，事务回滚。最小的执行单位为方法。决定执行成败是通过是否抛出异常来判断的，抛出异常即执行失败。 2、代码 (1) mysql建表语句 CREATE TABLE `t_student` ( `c_id` int(11) ...
spring 自定义事务管理器，编程式事务，声明式事务@Transactional使用
07-13
本代码使用H2内存数据库演示spring事务使用，包括编程式事务，声明式事务@Transactional使用，自定义事务事务注解实现自定义事务管理器
Spring源码剖析-事务源码之@Transactionl解析，java基础面试集合
2401_83621136的博客
04-01 700
在上一章我们分析了Spring的AOP的源码，本篇文章是对事务的源码分析，我们都知道事务的管理是基于AOP实现的，所以有了上一篇的铺垫这一章会比较简单一点。事务的源码我会分两章写，一张写Transcational的解析，一张写事务的执行流程。先上一个图，待会儿可以根据这个图来看源码事务配置案例配置事务管理器，开启注解事务支持开启事务支持事务管理器配置数据源…省略…标记方法需要事务//事务注解事务注解打在方法上，当然也是可以打在类上。事务注解原理。
spring源码阅读--@Transactional实现原理
热门推荐
嘎嘎的博客
12-07 5万+
@Transactional注解简介 @Transactional是spring中声明式事务管理的注解配置方式，相信这个注解的作用大家都很清楚。@Transactional注解可以帮助我们把事务开启、提交或者回滚的操作，通过aop的方式进行管理。通过@Transactional注解就能让spring为我们管理事务，免去了重复的事务管理逻辑，减少对业务代码的侵入，使我们开发人员能够专注于业务层面开发...
springboot @Transactional事务原理源码
successCodeMan的博客
02-04 243
如果说chain是空的，那么就会直接通过反射调用原始bean的方法，那就没有事务。扫描spring-boot-autoconfigure依赖包下的META-INF/spring.factories，加载文件里的TransactionAutoConfiguration类，可以看到sringboot在2.0之后默认使用了cglib代理，下面将的是jdk的代理，原理是一样的。
Spring中@Transactional的使用及事务源码分析
重口味码农
06-13 1万+
@Transactional Spring事务源码分析 本文讲解了Spring中最常用的注解@Transactional的各项属性的用法，分析了编程式事务和声明式事务的区别。并在源码的基础上分析了事务的实现机制，对了解事务的使用、彻底理解事务的实现颇有帮助。
spring boot@Transactional
12-21
在Java Spring Boot中，@Transactional是一个注解，用于标记一个方法或类需要进行事务管理。事务是一组操作的逻辑单元，要么全部成功执行，要么全部回滚。使用@Transactional注解可以确保在方法执行期间，如果发生异常或错误，所有对数据库的操作都会回滚到事务开始之前的状态。 当我们在一个方法上添加@Transactional注解时，Spring会自动为该方法创建一个事务，并在方法执行之前开启事务，在方法执行之后根据方法的执行结果决定是提交事务还是回滚事务。如果方法执行成功，事务将会被提交，如果方法执行失败，事务将会被回滚。 除了在方法上使用@Transactional注解，我们还可以将它应用于类级别。当我们在类级别上添加@Transactional注解时，该类中的所有方法都将被包装在一个事务中。 需要注意的是，@Transactional注解默认只对未检查异常（RuntimeException及其子类）进行回滚，对于检查异常（Exception及其子类）不会回滚。如果需要对检查异常进行回滚，可以使用@Transactional(rollbackFor = Exception.class)来指定回滚的异常类型。 另外，@Transactional注解还可以接收一些参数，用于配置事务的传播行为、隔离级别、超时时间等。例如，@Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.DEFAULT, timeout = 3600)。 总结一下，@Transactional注解是用于在Java Spring Boot中进行事务管理的注解，通过标记方法或类，可以确保一组操作要么全部成功执行，要么全部回滚。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值