@EnableTransactionManagement注解介绍、应用场景和示例代码

一、概述

@EnableTransactionManagement 是 Spring 框架中用于开启声明式事务管理的核心注解，作用是激活 Spring 容器对事务的支持，让开发者可以通过注解（如 @Transactional）快速实现事务控制，无需手动编写事务的开启、提交、回滚代码，简化开发流程、保证事务一致性。

核心底层原理：该注解会触发 Spring 自动注册 事务管理器（TransactionManager） 和 事务切面（TransactionAspect），通过 AOP 机制，在目标方法执行前后拦截，完成事务的自动管控（方法执行成功则提交事务，出现异常则回滚事务）。

注意要点：

该注解仅负责"开启事务支持"，具体事务规则（如隔离级别、传播行为、回滚条件）需配合 @Transactional 注解使用。
Spring Boot 项目中，若引入了 spring-boot-starter-jdbc/spring-boot-starter-data-jpa 等依赖，会自动配置 TransactionManager，此时 @EnableTransactionManagement 可省略（但手动添加更规范，便于后续扩展）。
非 Spring Boot 项目（如纯 Spring 项目），必须手动添加该注解，并配置 TransactionManager Bean，否则 @Transactional 注解无效。

二、属性（3个常用属性）

@EnableTransactionManagement 有3个可选属性，用于控制事务切面的生效方式，默认配置可满足绝大多数场景，无需额外修改。

属性名	类型	默认值	作用说明
mode	AdviceMode	PROXY	指定事务通知的实现方式：1. PROXY（默认）：通过 JDK 动态代理（接口实现类）或 CGLIB 代理（无接口类）实现，目标方法必须是非private、非final（否则代理失效，事务不生效）；2. ASPECTJ：通过 AspectJ 切面实现，支持 private/final 方法，需额外引入 AspectJ 依赖。
proxyTargetClass	boolean	false	仅当 mode=PROXY 时生效：1. false（默认）：优先使用 JDK 动态代理（目标类实现接口时）；2. true：强制使用 CGLIB 代理（无论目标类是否实现接口）。
order	int	Ordered.LOWEST_PRECEDENCE	指定事务切面的执行顺序（值越小，优先级越高），用于解决多个切面（如日志切面、权限切面）执行顺序冲突问题，避免事务切面被其他切面覆盖导致失效。

三、核心应用场景（必掌握）

@EnableTransactionManagement 的核心作用是"开启事务支持"，所有需要保证 数据一致性 的场景，都需要先开启该注解，再配合 @Transactional 使用。以下是实际开发中最常用的场景：

场景1：数据库CRUD操作（单表/多表）

最基础场景，适用于单个方法中包含多步数据库操作（如新增+修改、修改+删除），需保证所有操作同时成功或同时失败。

示例场景：用户注册时，需同时新增用户信息（user表）和用户角色关联（user_role表），若其中一步失败，两步操作均需回滚，避免数据错乱。

场景2：多数据源事务（分布式基础）

当项目中存在多个数据源（如MySQL+Oracle、主库+从库），需要对多个数据源的操作进行事务管控时，需开启 @EnableTransactionManagement，并配置多个 TransactionManager，通过 @Transactional 指定对应事务管理器。

场景3：嵌套事务/事务传播

当一个事务方法调用另一个事务方法时（如方法A调用方法B，两者均有事务），需通过事务传播行为（如 REQUIRED、REQUIRES_NEW）控制事务的嵌套规则，而这一切的前提是通过 @EnableTransactionManagement 开启事务支持。

场景4：异常回滚定制

默认情况下，Spring 事务仅对 未捕获的运行时异常（RuntimeException） 回滚，若需对 checked 异常（如 IOException）回滚，需通过 @Transactional(rollbackFor = 异常类.class) 定制，而该配置生效的前提是开启了 @EnableTransactionManagement。

场景5：纯Spring项目（非Boot）

Spring Boot 自动配置了 TransactionManager，可省略 @EnableTransactionManagement，但纯 Spring 项目（如 SSH、SSM 传统项目），必须手动在配置类上添加该注解，并手动配置 TransactionManager Bean，否则 @Transactional 无效。

禁忌场景（事务无效）

未添加 @EnableTransactionManagement（非Spring Boot自动配置场景）；
目标方法是 private、final 或 static（mode=PROXY 时，代理无法拦截）；
方法内部自调用（如方法A调用自身的方法B，方法B有@Transactional，此时代理不生效，事务无效）；
未配置 TransactionManager（纯Spring项目）。

四、示例代码（分2种场景，可直接运行）

以下示例基于 Spring Boot 2.7.x，分为「基础场景（单数据源）」和「进阶场景（多数据源+定制回滚）」，均包含完整依赖、配置、代码。

示例1：基础场景（单数据源，最常用）

步骤1：引入依赖（pom.xml）

XML 复制代码

<!-- Spring Boot 父依赖 -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.7.10</version>
    <relativePath/>
</parent>

<dependencies>
    <!-- Spring Boot Web（可选，用于接口测试） -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- Spring Boot 数据访问（自动配置JDBC和TransactionManager） -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <!-- MySQL 驱动 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </dependency>
    <!-- Lombok（简化实体类） -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

步骤2：配置文件（application.yml）

XML 复制代码

spring:
  # 数据库配置
  datasource:
    url: jdbc:mysql://localhost:3306/test_db?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver
  # JPA配置（简化SQL编写，可选，也可使用MyBatis）
  jpa:
    hibernate:
      ddl-auto: update # 自动创建/更新表结构
    show-sql: true # 打印SQL语句
    properties:
      hibernate:
        format_sql: true # 格式化SQL

步骤3：主启动类（添加@EnableTransactionManagement）

java 复制代码

package com.example.transaction;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.transaction.annotation.EnableTransactionManagement;

// 开启事务管理（Spring Boot可省略，但手动添加更规范）
@EnableTransactionManagement
@SpringBootApplication
public class TransactionDemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(TransactionDemoApplication.class, args);
    }
}

步骤4：实体类（User）

java 复制代码

package com.example.transaction.entity;

import lombok.Data;
import javax.persistence.*;

@Data
@Entity
@Table(name = "t_user")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String username;
    private String password;
    private String phone; // 手机号
}

步骤5：Repository（数据访问层）

java 复制代码

package com.example.transaction.repository;

import com.example.transaction.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

// JpaRepository 提供了基础CRUD方法，无需手动编写SQL
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
}

步骤6：Service（核心，添加@Transactional）

需求：新增用户后，手动抛出异常，测试事务回滚（新增操作应失败，数据库无新增数据）。

java 复制代码

package com.example.transaction.service;

import com.example.transaction.entity.User;
import com.example.transaction.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    /**
     * 新增用户（带事务）
     * @Transactional：标记该方法需要事务管控
     * rollbackFor = Exception.class：所有异常都回滚（默认仅运行时异常回滚）
     */
    @Transactional(rollbackFor = Exception.class)
    public void addUser(User user) {
        // 第一步：新增用户（数据库插入操作）
        userRepository.save(user);
        // 手动抛出异常，测试事务回滚
        throw new RuntimeException("模拟新增用户失败，触发事务回滚");
    }
}

步骤7：测试（Controller/单元测试）

java 复制代码

package com.example.transaction.controller;

import com.example.transaction.entity.User;
import com.example.transaction.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {

    @Autowired
    private UserService userService;

    // 接口测试：POST http://localhost:8080/user/add
    @PostMapping("/user/add")
    public String addUser(@RequestBody User user) {
        try {
            userService.addUser(user);
            return "新增成功";
        } catch (Exception e) {
            return "新增失败：" + e.getMessage();
        }
    }
}

测试结果

调用接口后，控制台打印异常信息，数据库中 t_user 表无新增数据，说明事务回滚生效（若未开启 @EnableTransactionManagement，事务无效，数据库会新增用户数据）。

示例2：进阶场景（多数据源+事务传播）

需求：存在两个数据源（test_db1、test_db2），分别对应 User 和 Order 实体，新增用户时同时新增订单，若订单新增失败，用户新增也回滚（事务传播行为：REQUIRED，默认）。

步骤1：新增依赖（不变，新增多数据源配置依赖）

XML 复制代码

<!-- 多数据源配置依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

步骤2：多数据源配置（application.yml）

XML 复制代码

spring:
  datasource:
    # 数据源1（test_db1：用户库）
    db1:
      url: jdbc:mysql://localhost:3306/test_db1?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
      username: root
      password: 123456
      driver-class-name: com.mysql.cj.jdbc.Driver
    # 数据源2（test_db2：订单库）
    db2:
      url: jdbc:mysql://localhost:3306/test_db2?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
      username: root
      password: 123456
      driver-class-name: com.mysql.cj.jdbc.Driver

步骤3：多数据源配置类（配置两个TransactionManager）

java 复制代码

package com.example.transaction.config;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.sql.DataSource;

// 开启事务管理，同时配置两个数据源和对应的事务管理器
@Configuration
@EnableTransactionManagement
public class DataSourceConfig {

    // 配置数据源1（主数据源，@Primary 标记）
    @Primary
    @Bean(name = "db1DataSource")
    @ConfigurationProperties(prefix = "spring.datasource.db1")
    public DataSource db1DataSource() {
        return DataSourceBuilder.create().build();
    }

    // 配置数据源1的事务管理器
    @Primary
    @Bean(name = "db1TransactionManager")
    public PlatformTransactionManager db1TransactionManager() {
        return new DataSourceTransactionManager(db1DataSource());
    }

    // 配置数据源2
    @Bean(name = "db2DataSource")
    @ConfigurationProperties(prefix = "spring.datasource.db2")
    public DataSource db2DataSource() {
        return DataSourceBuilder.create().build();
    }

    // 配置数据源2的事务管理器
    @Bean(name = "db2TransactionManager")
    public PlatformTransactionManager db2TransactionManager() {
        return new DataSourceTransactionManager(db2DataSource());
    }
}

步骤4：Service（指定不同事务管理器，测试事务传播）

java 复制代码

package com.example.transaction.service;

import com.example.transaction.entity.Order;
import com.example.transaction.entity.User;
import com.example.transaction.repository.OrderRepository;
import com.example.transaction.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class UserOrderService {

    @Autowired
    private UserRepository userRepository;
    @Autowired
    private OrderRepository orderRepository;

    // 新增用户（使用数据源1的事务管理器）
    @Transactional(transactionManager = "db1TransactionManager", rollbackFor = Exception.class)
    public void addUser(User user) {
        userRepository.save(user);
    }

    // 新增订单（使用数据源2的事务管理器）
    @Transactional(transactionManager = "db2TransactionManager", rollbackFor = Exception.class)
    public void addOrder(Order order) {
        orderRepository.save(order);
        // 手动抛出异常，测试事务传播（回滚自身和调用者的事务）
        throw new RuntimeException("订单新增失败，触发回滚");
    }

    // 核心方法：同时新增用户和订单，测试事务传播
    @Transactional(transactionManager = "db1TransactionManager", rollbackFor = Exception.class)
    public void addUserAndOrder(User user, Order order) {
        // 调用新增用户（同事务管理器，加入当前事务）
        addUser(user);
        // 调用新增订单（不同事务管理器，按传播行为管控，默认REQUIRED）
        addOrder(order);
    }
}

测试结果

调用 addUserAndOrder 方法后，订单新增抛出异常，此时：

订单新增操作回滚（test_db2 的 order 表无数据）；
用户新增操作也回滚（test_db1 的 user 表无数据）；
说明事务传播行为生效，@EnableTransactionManagement 成功管控多个事务管理器的事务。

五、常见问题排查（高频面试/开发坑）

问题1：@Transactional 注解无效，事务不回滚？排查：① 是否添加了 @EnableTransactionManagement；② 目标方法是否为 private/final/static；③ 是否配置了 TransactionManager；④ 异常是否被 try-catch 捕获（被捕获则无法触发回滚）。
问题2：多数据源场景下，事务只回滚其中一个数据源？排查：是否为每个数据源配置了对应的 TransactionManager，且 @Transactional 注解中指定了正确的 transactionManager。
问题3：mode=PROXY 时，内部方法调用事务无效？解决方案：① 避免内部自调用；② 改用 mode=ASPECTJ（需引入 AspectJ 依赖）；③ 通过 Spring 上下文获取自身 Bean，再调用方法。
问题4：Spring Boot 项目省略 @EnableTransactionManagement 也能生效？原因：Spring Boot 自动配置类（DataSourceTransactionManagerAutoConfiguration）会自动开启事务支持，若需定制事务属性（如 mode、order），仍需手动添加该注解。

六、总结

@EnableTransactionManagement 是 Spring 声明式事务的"开关"，核心作用是激活事务切面和事务管理器，必须与 @Transactional 配合使用。
核心应用场景：所有需要保证数据一致性的数据库操作（单表/多表、单数据源/多数据源）。
关键注意点：避免 private/final 方法、避免内部自调用、正确配置 TransactionManager，这些是事务生效的核心前提。
Spring Boot 可省略该注解，但手动添加更规范，便于后续扩展（如定制事务切面顺序、切换代理模式）。