`@EnableTransactionManagement` 注解深度解析

最新推荐文章于 2025-07-02 10:00:00 发布
原创 最新推荐文章于 2025-07-02 10:00:00 发布 · 1.2k 阅读 · 22 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#spring #源码 #事务 #学习

@EnableTransactionManagement 注解深度解析

@EnableTransactionManagement 是 Spring 框架中用于启用声明式事务管理的核心注解，它替代了传统的 XML 配置方式（如 <tx:annotation-driven/>），通过简洁的注解驱动方式激活 Spring 的事务管理能力。以下从注解定义、工作原理、源码实现及最佳实践四个维度展开详细解析。

一、注解定义与核心作用

1. 注解定义

@EnableTransactionManagement 位于 org.springframework.transaction.annotation 包中，其源码定义如下：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(TransactionManagementConfigurationSelector.class)
public @interface EnableTransactionManagement {

    /**
     * 是否使用 CGLIB 代理（默认 false，优先使用 JDK 动态代理）
     */
    boolean proxyTargetClass() default false;

    /**
     * 事务通知模式（默认 AdviceMode.PROXY）
     */
    AdviceMode mode() default AdviceMode.PROXY;

    /**
     * 事务通知的执行顺序（默认最低优先级）
     */
    int order() default Ordered.LOWEST_PRECEDENCE;
}

2. 核心作用

  • 激活声明式事务：启用基于 @Transactional 注解的事务管理能力
  • 注册事务基础设施：自动配置事务相关的 Bean（如事务拦截器、事务属性源等）
  • 代理机制控制：通过 proxyTargetClass 控制代理方式（JDK 或 CGLIB）
  • 通知模式选择：支持 PROXY（代理）和 ASPECTJ（AspectJ 织入）两种模式

二、工作原理：事务管理的激活流程

1. 核心工作流程

graph TD
    A[添加 @EnableTransactionManagement] --> B[导入 TransactionManagementConfigurationSelector]
    B --> C{选择 AdviceMode}
    C -->|PROXY| D[注册 AutoProxyRegistrar]
    C -->|ASPECTJ| E[注册 AspectJTransactionManagementConfiguration]
    D --> F[注册 InfrastructureAdvisorAutoProxyCreator]
    F --> G[创建事务代理对象]
    G --> H[拦截 @Transactional 方法]

2. 关键组件说明

组件作用
TransactionManagementConfigurationSelector根据 mode 属性选择导入的配置类
AutoProxyRegistrar注册 InfrastructureAdvisorAutoProxyCreator（代理创建器）
ProxyTransactionManagementConfiguration配置 JDK/CGLIB 代理模式的事务基础设施（拦截器、属性源等）
InfrastructureAdvisorAutoProxyCreator扫描 @Transactional 注解并创建代理对象
TransactionInterceptor事务方法拦截器，处理事务的开启、提交、回滚

三、源码深度解析

1. 入口：@EnableTransactionManagement

注解通过 @Import(TransactionManagementConfigurationSelector.class) 导入选择器：

@Import(TransactionManagementConfigurationSelector.class)
public @interface EnableTransactionManagement { ... }

2. 配置选择器：TransactionManagementConfigurationSelector

根据 AdviceMode 选择导入的配置类：

public class TransactionManagementConfigurationSelector 
    extends AdviceModeImportSelector<EnableTransactionManagement> {

    @Override
    protected String[] selectImports(AdviceMode adviceMode) {
        switch (adviceMode) {
            case PROXY:
                // 默认模式：导入代理相关配置
                return new String[] {
                    AutoProxyRegistrar.class.getName(),
                    ProxyTransactionManagementConfiguration.class.getName()
                };
            case ASPECTJ:
                // AspectJ 模式：导入 AspectJ 事务配置
                return new String[] {
                    TransactionManagementConfigUtils.TRANSACTION_ASPECT_CONFIGURATION_CLASS_NAME
                };
            default:
                return null;
        }
    }
}

3. 代理模式配置：ProxyTransactionManagementConfiguration

这是事务管理的核心配置类，定义了事务拦截器、属性源等关键组件：

@Configuration
public class ProxyTransactionManagementConfiguration 
    extends AbstractTransactionManagementConfiguration {

    // 注册事务属性源（解析 @Transactional 注解）
    @Bean
    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    public TransactionAttributeSource transactionAttributeSource() {
        return new AnnotationTransactionAttributeSource();
    }

    // 注册事务拦截器（方法拦截逻辑）
    @Bean
    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    public TransactionInterceptor transactionInterceptor() {
        TransactionInterceptor interceptor = new TransactionInterceptor();
        interceptor.setTransactionAttributeSource(transactionAttributeSource());
        if (this.txManager != null) {
            interceptor.setTransactionManager(this.txManager);
        }
        return interceptor;
    }

    // 注册事务通知器（Advisor）
    @Bean(name = TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME)
    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    public BeanFactoryTransactionAttributeSourceAdvisor transactionAdvisor() {
        BeanFactoryTransactionAttributeSourceAdvisor advisor = 
            new BeanFactoryTransactionAttributeSourceAdvisor();
        advisor.setTransactionAttributeSource(transactionAttributeSource());
        advisor.setAdvice(transactionInterceptor());
        advisor.setOrder(this.enableTx.<Integer>getNumber("order"));
        return advisor;
    }
}

4. 事务属性源：AnnotationTransactionAttributeSource

负责解析 @Transactional 注解的属性：

public class AnnotationTransactionAttributeSource 
    extends AbstractTransactionAttributeSource {

    // 解析方法或类上的 @Transactional 注解
    @Override
    protected TransactionAttribute findTransactionAttribute(Method method) {
        return determineTransactionAttribute(method);
    }

    private TransactionAttribute determineTransactionAttribute(AnnotatedElement element) {
        // 查找 @Transactional 注解
        Transactional transactional = AnnotatedElementUtils.findMergedAnnotation(
            element, Transactional.class);
        
        if (transactional != null) {
            // 将注解属性转换为 TransactionAttribute
            return parseTransactionAnnotation(transactional);
        }
        return null;
    }

    protected TransactionAttribute parseTransactionAnnotation(Transactional ann) {
        RuleBasedTransactionAttribute rbta = new RuleBasedTransactionAttribute();
        rbta.setPropagationBehavior(ann.propagation().value());
        rbta.setIsolationLevel(ann.isolation().value());
        rbta.setTimeout(ann.timeout());
        rbta.setReadOnly(ann.readOnly());
        rbta.setQualifier(ann.value());
        // 设置回滚规则
        List<RollbackRuleAttribute> rollbackRules = new ArrayList<>();
        for (Class<?> rbRule : ann.rollbackFor()) {
            rollbackRules.add(new RollbackRuleAttribute(rbRule));
        }
        for (String rbRule : ann.rollbackForClassName()) {
            rollbackRules.add(new RollbackRuleAttribute(rbRule));
        }
        for (Class<?> rbRule : ann.noRollbackFor()) {
            rollbackRules.add(new NoRollbackRuleAttribute(rbRule));
        }
        for (String rbRule : ann.noRollbackForClassName()) {
            rollbackRules.add(new NoRollbackRuleAttribute(rbRule));
        }
        rbta.setRollbackRules(rollbackRules);
        return rbta;
    }
}

5. 事务拦截器：TransactionInterceptor

实现事务方法拦截的核心逻辑：

public class TransactionInterceptor extends TransactionAspectSupport 
    implements MethodInterceptor, Serializable {

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        Class<?> targetClass = (invocation.getThis() != null ? 
            AopUtils.getTargetClass(invocation.getThis()) : null);
        
        // 在事务上下文中执行方法
        return invokeWithinTransaction(
            invocation.getMethod(), targetClass, new InvocationCallback() {
                @Override
                public Object proceedWithInvocation() throws Throwable {
                    return invocation.proceed();
                }
            });
    }
}

6. 事务执行核心：TransactionAspectSupport.invokeWithinTransaction()

处理事务的开启、提交和回滚：

public abstract class TransactionAspectSupport implements BeanFactoryAware {
    
    protected Object invokeWithinTransaction(Method method, Class<?> targetClass, 
            final InvocationCallback invocation) throws Throwable {
        
        // 获取事务属性
        TransactionAttribute txAttr = getTransactionAttributeSource()
            .getTransactionAttribute(method, targetClass);
        
        // 获取事务管理器
        PlatformTransactionManager tm = determineTransactionManager(txAttr);
        
        // 创建事务
        TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, methodIdentification);
        
        Object retVal;
        try {
            // 执行业务方法
            retVal = invocation.proceedWithInvocation();
        } catch (Throwable ex) {
            // 异常处理：回滚或提交
            completeTransactionAfterThrowing(txInfo, ex);
            throw ex;
        } finally {
            cleanupTransactionInfo(txInfo);
        }
        
        // 提交事务
        commitTransactionAfterReturning(txInfo);
        return retVal;
    }
    
    // 异常处理逻辑
    protected void completeTransactionAfterThrowing(TransactionInfo txInfo, Throwable ex) {
        if (txInfo != null && txInfo.hasTransaction()) {
            // 判断是否需要回滚
            if (txInfo.transactionAttribute.rollbackOn(ex)) {
                try {
                    txInfo.getTransactionManager().rollback(txInfo.getTransactionStatus());
                } catch (TransactionSystemException ex2) {
                    // 处理回滚异常
                }
            } else {
                // 提交事务
                try {
                    txInfo.getTransactionManager().commit(txInfo.getTransactionStatus());
                } catch (TransactionSystemException ex2) {
                    // 处理提交异常
                }
            }
        }
    }
}

四、完整配置示例与最佳实践

1. 基础配置示例

@Configuration
@EnableTransactionManagement // 启用声明式事务
@ComponentScan("com.example")
public class AppConfig {

    // 配置数据源
    @Bean
    public DataSource dataSource() {
        return DataSourceBuilder.create()
            .url("jdbc:mysql://localhost:3306/mydb")
            .username("root")
            .password("password")
            .build();
    }

    // 配置事务管理器
    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }
}

2. 高级配置（自定义事务管理器）

@Configuration
@EnableTransactionManagement(
    proxyTargetClass = true, // 强制使用 CGLIB 代理
    order = Ordered.HIGHEST_PRECEDENCE // 最高优先级
)
public class AdvancedTransactionConfig {

    @Bean
    public PlatformTransactionManager transactionManager(EntityManagerFactory emf) {
        JpaTransactionManager tm = new JpaTransactionManager();
        tm.setEntityManagerFactory(emf);
        tm.setDefaultTimeout(30); // 全局超时时间 30 秒
        return tm;
    }
}

3. 服务层使用事务

@Service
public class OrderService {

    @Autowired
    private OrderRepository orderRepository;
    
    @Transactional(
        propagation = Propagation.REQUIRED,
        isolation = Isolation.READ_COMMITTED,
        rollbackFor = {BusinessException.class},
        timeout = 10
    )
    public Order createOrder(Order order) {
        // 业务逻辑...
        return orderRepository.save(order);
    }
}

五、高级特性与最佳实践

1. 多数据源事务管理

当系统使用多个数据源时，需为每个数据源配置独立的事务管理器：

@Configuration
@EnableTransactionManagement
public class MultiDataSourceConfig {

    @Primary
    @Bean
    public DataSource primaryDataSource() {
        // 主数据源配置
    }

    @Bean
    public DataSource secondaryDataSource() {
        // 从数据源配置
    }

    @Primary
    @Bean
    public PlatformTransactionManager primaryTxManager(DataSource primaryDataSource) {
        return new DataSourceTransactionManager(primaryDataSource);
    }

    @Bean
    public PlatformTransactionManager secondaryTxManager(DataSource secondaryDataSource) {
        return new DataSourceTransactionManager(secondaryDataSource);
    }
}

// 使用指定事务管理器
@Service
public class ReportService {

    @Transactional("secondaryTxManager")
    public Report generateReport() {
        // 使用从数据源
    }
}

2. 事务传播行为控制

通过 @Transactional 的 propagation 属性控制事务传播：

public class OrderService {

    @Transactional(propagation = Propagation.REQUIRED)
    public void processOrder(Order order) {
        // 主订单逻辑
        processPayment(order); // 调用支付服务
    }
    
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void processPayment(Order order) {
        // 支付逻辑（独立事务）
    }
}

3. 事务监听器

通过 @TransactionalEventListener 监听事务事件：

@Component
public class OrderEventListener {

    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
    public void handleOrderCreated(OrderCreatedEvent event) {
        // 订单创建成功后发送通知
    }
}

六、常见问题与解决方案

1. 事务不生效的排查

  1. 检查注解位置：@EnableTransactionManagement 需标注在 @Configuration 类上
  2. 确认代理模式：目标类需被 Spring 代理（检查 Bean 类型是否为 XXX$$EnhancerBySpringCGLIB）
  3. 方法可见性：@Transactional 仅对 public 方法生效
  4. 异常类型匹配：默认只回滚 RuntimeException 和 Error，需通过 rollbackFor 自定义

2. 性能优化建议

  1. 避免大事务：减少事务中的业务逻辑，缩短事务持有时间
  2. 合理设置超时：防止长事务阻塞资源
    @Transactional(timeout = 5) // 5秒超时
  3. 只读事务优化：对查询方法启用只读事务
    @Transactional(readOnly = true)
public List<Order> findOrders() { ... }

3. 分布式事务集成

结合 Atomikos 实现 JTA 分布式事务：

@Configuration
@EnableTransactionManagement
public class JtaConfig {

    @Bean
    public UserTransaction userTransaction() throws SystemException {
        UserTransactionImp userTransaction = new UserTransactionImp();
        userTransaction.setTransactionTimeout(30);
        return userTransaction;
    }

    @Bean
    public PlatformTransactionManager transactionManager() {
        return new JtaTransactionManager(userTransaction());
    }
}

七、总结

@EnableTransactionManagement 是 Spring 声明式事务管理的核心入口，其工作原理可概括为：

  1. 导入配置选择器：根据 mode 属性选择代理或 AspectJ 模式
  2. 注册代理创建器：通过 AutoProxyRegistrar 注册 InfrastructureAdvisorAutoProxyCreator
  3. 配置事务基础设施：ProxyTransactionManagementConfiguration 定义事务拦截器、属性源等
  4. 创建事务代理：扫描 @Transactional 方法并生成代理对象
  5. 拦截事务方法：通过 TransactionInterceptor 处理事务的开启、提交和回滚

最佳实践建议：

  • 配置事务管理器：必须显式配置 PlatformTransactionManager Bean
  • 合理选择代理模式：优先使用默认的 PROXY 模式
  • 控制事务粒度：避免在事务中包含过多业务逻辑
  • 明确事务属性：显式指定传播行为、隔离级别等属性

理解 @EnableTransactionManagement 的源码实现，有助于开发者：

  • 深入掌握 Spring 事务的工作原理
  • 高效排查事务相关的问题
  • 根据业务需求进行高级定制
  • 构建高性能、高可靠的事务管理方案
Spring @Transactional注解原理深度分析
ma451152002的专栏
06-17 247
Transactional注解是Spring事务管理的核心注解，定义在spring-tx@Inherited// 事务管理器限定符// 事务标签// 事务传播行为// 事务隔离级别// 事务超时时间// 只读事务标识// 回滚异常类型Class<?// 不回滚异常类型Class<?/*** 根据事务定义获取事务状态*//*** 提交事务*//*** 回滚事务*/@Component。
spring 事务 @EnableTransactionManagement原理
sjtu_chenchen的专栏
06-10 1万+
@EnableXXX原理：注解上有个XXXRegistrar，或通过XXXSelector引入XXXRegistrar，XXXRegistrar实现了 ImportBeanDefinitionRegistrar的registerBeanDefinitions方法，给容器注册XXXCreator。这个Creator实现了后置处理器， 后置处理器在对象创建以后，包装对象，返回一个代理对象，代理对象...
Spring事务之@EnableTransactionManagement
于琦海
11-13 1万+
@EnableTransactionManagement源码解析，本文主要介绍注解是怎么开启事务的。
springboot如何开启事务@Transactional
OceanSky的专栏
05-26 4575
上图展示了springboot事务管理器实现的一个结构图，直接使用的是JdbcTransactionManager事务管理器，spring的核心接口是PlatformTransactionManager； 一、通过自动化配置类TransactionAutoConfiguration启动spring事务 @Configuration(proxyBeanMethods = false) @ConditionalOnBean(TransactionManager.class) @Conditional..
SpringBoot事务注解详解
西魏陶渊明的博客
05-11 1782
关系型数据库多用到事务，在传统项目中使用xml配置，配置虽然也还好，但是看着很不美观，在使用SpringBoot框架，就简单的多了，以实战为准，直接上代码 @Transactional spring 事务注解 1.简单开启事务管理 @EnableTransactionManagement // 启注解事务管理，等同于xml配置方式的 <tx:annotation-driv...
Spring源码-@EnableTransactionManagement方式事务实现分析（上）
it_lihongmin的博客
11-09 6680
先总览实现逻辑： @EnableTransactionManagement使用 @Import方式，注入TransactionManagementConfigurationSelector的Bean，相当于间接注入了以下两个bean 1、AutoProxyRegistrar 实现了ImportBeanDefinitionRegistrar接口，在registerBean...
Spring事务管理深度解析：AOP机制与实战要点
趁年轻，多去失败
07-02 883
Spring事务机制核心原理：基于AOP动态代理实现，通过@Transactional注解定义事务属性，TransactionInterceptor拦截方法调用，结合PlatformTransactionManager执行事务操作（开启/提交/回滚）。默认只对未检查异常回滚，需注意自调用导致的事务失效问题。 关键点摘要： 代理模式：JDK/CGLIB动态代理实现事务逻辑与业务代码解耦 注解驱动：@Transactional配置传播行为、隔离级别等属性 拦截流程：方法调用→代理拦截→事务管理器操作→清理资源
Spring AOP 在 Spring Framework 中的应用深度解析
核心API包括`@EnableTransactionManagement`用于开启事务管理，`@Transactional`用于标注需要事务管理的方法，`@TransactionalEventListener`则用于监听事务事件。`TransactionDefinition`定义了事务属性，`...
Java实用注解篇：@Transactional 事务失效的场景深度解析
x²
03-11 3775
在使用明明加了事务注解，但事务却没有生效，数据库操作仍然被提交了！这是因为事务机制的触发有一些前提条件，只要触碰到事务失效的“雷区”，就会让事务变成“摆设”。接下来，我们来详细剖析几种常见的事务失效场景以及解决方案！
如果你是一名专业的java高级架构师，现在你在面试知识，如下是Spring和SpringMVC的面试知识体系结构图 请按照这个体系给出每个知识点的学习理解方便记忆和消化，同时给出每个知识点的高频面试的标准面试答案，结合项目经验给出解释和实战 Spring和SpringMVC面试核心知识体系 ├── 一、Spring框架基础 │ ├── 核心概念 │ │ ├── Spring是什么？有哪些核心优势？（解耦、集成、AOP等） │ │ ├── IoC（控制反转）和DI（依赖注入）：概念、区别与好处？ │ │ └：Spring容器：BeanFactory vs ApplicationContext区别？ │ ├── 配置方式 │ │ ├── 有哪几种配置方式？（XML、注解、Java Config） │ │ ├── @Configuration + @Bean 与 @Component 的区别？ │ │ └── 如何混合使用不同的配置方式？ │ └── Bean管理 │ ├── Bean的作用域：singleton, prototype, request等区别？ │ ├── Bean的生命周期：从创建到销毁的完整流程？ │ └── 循环依赖问题：什么是循环依赖？Spring如何解决（三级缓存）？ ├── 二、IoC（控制反转）与DI（依赖注入）深度解析 │ ├── 依赖注入方式 │ │ ├── 构造器注入 vs Setter注入：推荐哪种？为什么？ │ │ ├── 字段注入（@Autowired）的优缺点？ │ │ └── @Autowired, @Resource, @Inject 注解的区别？ │ ├── 自动装配 │ │ ├── 自动装配的模式（byName, byType等）？ │ │ ├── @Primary 和 @Qualifier 注解的作用与区别？ │ │ └：如何解决自动装配时的歧义性？ │ └── 条件化装配 │ ├── @Profile：作用？如何激活不同环境的配置？ │ └── @Conditional：原理？如何自定义条件？ ├── 三、AOP（面向切面编程） │ ├── AOP核心概念 │ │ ├── AOP解决了什么问题？主要应用场景？（日志、事务、安全等） │ │ ├── 连接点（Joinpoint）、切点（Pointcut）、通知（Advice）、切面（Aspect）概念？ │ │ └── 织入（Weaving）：编译期、类加载期、运行期织入区别？ │ ├── 代理机制 │ │ ├── Spring AOP默认使用哪种代理？JDK动态代理 vs CGLIB代理区别？ │ │ └── 什么情况下使用CGLIB代理？ │ └── 通知类型与使用 │ ├── 5种通知类型：@Before, @After, @AfterReturning, @AfterThrowing, @Around │ ├── @Around 和其他通知的区别？如何控制目标方法执行？ │ └── 如何获取方法参数、方法名等信息（JoinPoint, ProceedingJoinPoint）？ ├── 四、Spring事务管理 │ ├── 事务核心接口 │ │ ├── PlatformTransactionManager：作用？常见实现类（DataSourceTransactionManager等） │ │ ├── TransactionDefinition：定义事务属性（传播行为、隔离级别等） │ │ └── TransactionStatus：描述事务状态 │ ├── 声明式事务 │ │ ├── 如何开启声明式事务？（@EnableTransactionManagement） │ │ ├── @Transactional 注解可以作用在哪些地方？（类、方法）优先级？ │ │ └── 事务失效的常见场景？（非public方法、自调用、异常被捕获等） │ └── 事务属性 │ ├── 传播行为（Propagation）：REQUIRED, REQUIRES_NEW, NESTED等区别？ │ ├── 隔离级别（Isolation）：READ_UNCOMMITTED, READ_COMMITTED等与数据库关系？ │ └── 回滚规则：如何设置回滚/不回滚的异常类型？ ├── 五、Spring MVC核心架构 │ ├── 请求处理流程 │ │ ├── 描述一次请求的完整处理流程（DispatcherServlet -> 控制器 -> 视图）？ │ │ ├── 核心组件：DispatcherServlet, HandlerMapping, HandlerAdapter, ViewResolver作用？ │ │ └── 流程图的关键步骤是什么？ │ ├── 控制器（Controller） │ │ ├── @Controller 和 @RestController 的区别？ │ │ ├── 常用注解：@RequestMapping, @GetMapping, @PostMapping等 │ │ └── @ResponseBody 的作用？如何将返回值转为JSON（HttpMessageConverter）？ │ └── 数据处理与视图解析 │ ├── 参数绑定：@RequestParam, @PathVariable, @RequestBody, @ModelAttribute区别？ │ ├── 数据模型：Model, ModelMap, ModelAndView 的使用？ │ └── 视图解析：InternalResourceViewResolver如何工作？ ├── 六、Spring MVC高级特性 │ ├── 拦截器（Interceptor） │ │ ├── 拦截器 vs 过滤器（Filter）的区别？ │ │ ├── 拦截器的三个方法：preHandle, postHandle, afterCompletion执行时机？ │ │ └── 如何配置多个拦截器？执行顺序？ │ ├── 统一异常处理 │ │ ├── @ControllerAdvice + @ExceptionHandler 如何实现全局异常处理？ │ │ ├── HandlerExceptionResolver 接口的作用？ │ │ └── @ResponseStatus 注解的使用？ │ └── 文件上传与Restful API │ ├── 如何实现文件上传？（MultipartResolver） │ ├── Restful风格API的设计原则？（GET/POST/PUT/DELETE） │ └── 如何解决跨域问题？（@CrossOrigin, CorsFilter） ├── 七、Spring与第三方框架集成 │ ├── 数据访问 │ │ ├── Spring JDBC：JdbcTemplate的优势？ │ │ ├── 集成MyBatis：需要哪些配置？@MapperScan作用？ │ │ └── 集成JPA（Hibernate）：如何配置？ │ ├── 测试框架 │ │ ├── Spring TestContext Framework：@SpringBootTest, @DataJpaTest等 │ │ ├── 如何模拟MVC测试？（@WebMvcTest, MockMvc） │ │ └── 如何 mock Bean？（@MockBean） │ └── 其他集成 │ ├── 如何集成缓存？（@Cacheable, 支持Redis, Ehcache等） │ └── 如何集成任务调度？（@Scheduled, @Async） ├── 八、Spring新特性与原理进阶 │ ├── Spring Boot关联 │ │ ├── Spring Boot 和 Spring 的关系？自动配置原理？ │ │ └── starter 的作用？如何自定义 starter？ │ ├── 设计模式应用 │ │ ├── Spring中使用了哪些设计模式？（工厂、单例、代理、模板方法等） │ │ └── 举例说明模板方法模式在JdbcTemplate中的应用？ │ └── 源码与原理 │ ├── Spring如何管理单例Bean的线程安全问题？ │ ├── ApplicationContext的刷新流程（refresh()方法）大致过程？ │ └── Spring事件机制（ApplicationEvent、ApplicationListener）？ └── 九、常见问题与解决方案 ├── 性能与配置 │ ├── 如何优化Spring应用启动速度？（懒加载、组件扫描路径优化） │ └── 如何外部化配置？（@PropertySource, @Value, @ConfigurationProperties） ├── 开发实践 │ ├── 如何优雅地读取配置文件？ │ ├── Spring中有哪些扩展点？（BeanPostProcessor, BeanFactoryPostProcessor） │ └── 如何自定义注解并使其生效？ └── 疑难杂症 ├── @Transactional 和 @Async 在同一个类中调用为什么失效？（代理机制） └── 如何解决Spring应用中的内存泄漏问题？
最新发布
09-29
### 二、IoC与DI深度解析 #### 学习理解 - **注入方式**：构造器注入（强制依赖）vs Setter注入（可选依赖） - **@Primary vs @Qualifier**：前者用于主Bean选择，后者用于精确指定Bean名称 #### 高频面试答案 **Q...
Spring事务二：@EnableTransactionManagement
万物皆字节
09-20 1850
接上一篇《Spring事务一：tx 标签》 在使用Spring-boot的时候，如果我们想开启事务可以在启动类上加一个注解 @EnableTransactionManagement，下面我们来分析一下内在原理
Spring 事务原理篇：@EnableTransactionManagement注解底层原理分析技巧，就算你看不懂源码，也要学会这个技巧！
avengerEug的博客
07-08 1937
前言 学习了关于Spring AOP原理以及事务的基础知识后，今天咱们来聊聊Spring在底层是如何操作事务的。如果阅读到此文章，并且对Spring AOP原理不太了解的话，建议先阅读下本人的这篇文章：Spring AOP原理篇：我用上我的洪荒之力来帮你彻底了解aop注解@EnableAspectJAutoProxy的原理的文章，后文的内容与这篇文章有很大的关联关系。 一、先说说@EnableTransactionManagement注解内部有哪些方法 我们看下@EnableTransactionM
@EnableTransactionManagement注解理解
dichengyan0013的博客
12-14 1454
@EnableTransactionManagement表示开启事务支持，在springboot项目中一般配置在启动类上，效果等同于xml配置的<tx:annotation-driven />。开启事务支持后，然后在访问数据库的Service方法上添加注解 @Transactional 便可。 转载于:https://www.cnblogs.com/shamo89/p/...
Spring事务原理分析(一)--@EnableTransactionManagement 到底做了什么？
weixiaohuai的博客
02-01 1万+
目录 一、概述 二、事务的ACID属性 三、事务的隔离级别 四、事务的传播行为 五、Spring声明式事务环境搭建 六、@EnableTransactionManagement分析 七、AutoProxyRegistrar类分析 八、ProxyTransactionManagementConfiguration类分析 九、总结 一、概述 在分析Spring事务原理之前，我们有必要先回顾下数据库事务相关的知识。如事务的概念、事务的属性、事务隔离级别、事务传播行为等。 首先介绍一些什么是
@EnableTransactionManagement的使用及分析
热门推荐
前路无畏的博客
04-10 1万+
使用spring事务的时候有一个总开关@EnableTransactionManagement 1. 事务管理器 Spring Boot 使用事务非常简单 使用注解 @EnableTransactionManagement 开启事务支持后 在访问数据库的Service方法上添加注解 @Transactional 便可 关于事务管理器，不管是JPA还是JDBC等都实现自接口 PlatformTransactionManager 。 如果你添加的是 spring-boot-starter-jdbc 依赖，
32.Spring事务原理之@EnableTransactionManagement
qq_30635523的博客
06-15 1439
highlight: arduino-light 9.Spring事务原理之@EnableTransactionManagement Spring提供的AOP功能有两种实现方式，可选值有PROXY 和 ASPECTJ,默认值为AdviceMode.PROXY。 一种是Spring自带的AOP功能，主要靠JDK代理和CGLIB代理实现，另外一种是通过第三方框架ASPECTJ实现。 @En...
@EnableTransactionManagement 这个注解是什么意思
一切从零开始
06-20 2990
@EnableTransactionManagement
@EnableTransactionManagement
weixin_43705952的博客
11-07 553
@GetMapping("/saveData") @ApiOperation("传感器数据上云-红外测温及气体") @Transactional(rollbackFor = Exception.class) public WebResult saveData(InfrareDataReqVo infrareDataReqVo){ try { PigHeatEntity pigHeatEntity=new PigHeatEntity();
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值