数据访问层深度实践

// Spring Boot 自动配置数据源的核心逻辑
@Configuration(proxyBeanMethods = false)
@ConditionalOnClass({ DataSource.class, EmbeddedDatabaseType.class })
@ConditionalOnMissingBean(type = "io.r2dbc.spi.ConnectionFactory")
@EnableConfigurationProperties(DataSourceProperties.class)
@Import({
    DataSourcePoolMetadataProvidersConfiguration.class,
    DataSourceInitializationConfiguration.class
})
public class DataSourceAutoConfiguration {

    // 内嵌数据库配置（H2/HSQL/Derby）
    @Configuration(proxyBeanMethods = false)
    @Conditional(EmbeddedDatabaseCondition.class)
    @ConditionalOnMissingBean({ DataSource.class, XADataSource.class })
    @Import(EmbeddedDataSourceConfiguration.class)
    protected static class EmbeddedDatabaseConfiguration {}

    // 连接池配置（HikariCP 优先）
    @Configuration(proxyBeanMethods = false)
    @Conditional(PooledDataSourceCondition.class)
    @ConditionalOnMissingBean({ DataSource.class, XADataSource.class })
    @Import({
        HikariConfiguration.class,   // 优先使用 HikariCP
        Tomcat.class,                 // 其次 Tomcat JDBC Pool
        Dbcp2.class,                  // 再次 DBCP2
        Generic.class,
        DataSourceJmxConfiguration.class
    })
    protected static class PooledDataSourceConfiguration {}
}

// DataSourceBuilder 核心源码
public final class DataSourceBuilder<T extends DataSource> {

    private Class<? extends DataSource> type;
    private ClassLoader classLoader;
    private Map<String, String> properties = new LinkedHashMap<>();

    // 根据类路径自动推断数据源类型
    public static Class<? extends DataSource> findType(ClassLoader classLoader) {
        // 优先级：HikariCP > Tomcat > DBCP2 > Oracle UCP > Generic
        if (ClassUtils.isPresent("com.zaxxer.hikari.HikariDataSource", classLoader)) {
            return HikariDataSource.class;
        }
        if (ClassUtils.isPresent("org.apache.tomcat.jdbc.pool.DataSource", classLoader)) {
            return org.apache.tomcat.jdbc.pool.DataSource.class;
        }
        if (ClassUtils.isPresent("org.apache.commons.dbcp2.BasicDataSource", classLoader)) {
            return BasicDataSource.class;
        }
        // ... 其他数据源类型
        return null;
    }

    // 构建数据源实例
    public T build() {
        Class<? extends DataSource> type = getType();
        DataSource dataSource = BeanUtils.instantiateClass(type);
        // 通过反射设置属性
        bind(dataSource);
        return (T) dataSource;
    }
}

// 多数据源配置示例
@Configuration
public class MultiDataSourceConfig {

    // 主数据源（primary）
    @Bean
    @Primary
    @ConfigurationProperties(prefix = "spring.datasource.primary")
    public DataSource primaryDataSource() {
        return DataSourceBuilder.create().type(HikariDataSource.class).build();
    }

    // 从数据源（secondary）
    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.secondary")
    public DataSource secondaryDataSource() {
        return DataSourceBuilder.create().type(HikariDataSource.class).build();
    }
}

## application.yml 多数据源配置
spring:
  datasource:
    primary:
      jdbc-url: jdbc:mysql://localhost:3306/main_db?useSSL=false&serverTimezone=Asia/Shanghai
      username: root
      password: root123
      driver-class-name: com.mysql.cj.jdbc.Driver
      hikari:
        maximum-pool-size: 20
        minimum-idle: 5
    secondary:
      jdbc-url: jdbc:mysql://localhost:3306/log_db?useSSL=false&serverTimezone=Asia/Shanghai
      username: root
      password: root123
      driver-class-name: com.mysql.cj.jdbc.Driver
      hikari:
        maximum-pool-size: 10
        minimum-idle: 2

// 主数据源 JPA 配置
@Configuration
@EnableJpaRepositories(
    basePackages = "com.example.repository.primary",
    entityManagerFactoryRef = "primaryEntityManagerFactory",
    transactionManagerRef = "primaryTransactionManager"
)
public class PrimaryJpaConfig {

    @Bean
    @Primary
    public LocalContainerEntityManagerFactoryBean primaryEntityManagerFactory(
            EntityManagerFactoryBuilder builder,
            @Qualifier("primaryDataSource") DataSource dataSource) {
        return builder
            .dataSource(dataSource)
            .packages("com.example.entity.primary")
            .persistenceUnit("primary")
            .build();
    }

    @Bean
    @Primary
    public PlatformTransactionManager primaryTransactionManager(
            @Qualifier("primaryEntityManagerFactory") EntityManagerFactory emf) {
        return new JpaTransactionManager(emf);
    }
}

// 从数据源 JPA 配置
@Configuration
@EnableJpaRepositories(
    basePackages = "com.example.repository.secondary",
    entityManagerFactoryRef = "secondaryEntityManagerFactory",
    transactionManagerRef = "secondaryTransactionManager"
)
public class SecondaryJpaConfig {

    @Bean
    public LocalContainerEntityManagerFactoryBean secondaryEntityManagerFactory(
            EntityManagerFactoryBuilder builder,
            @Qualifier("secondaryDataSource") DataSource dataSource) {
        return builder
            .dataSource(dataSource)
            .packages("com.example.entity.secondary")
            .persistenceUnit("secondary")
            .build();
    }

    @Bean
    public PlatformTransactionManager secondaryTransactionManager(
            @Qualifier("secondaryEntityManagerFactory") EntityManagerFactory emf) {
        return new JpaTransactionManager(emf);
    }
}

// MyBatis-Plus 多数据源配置
@Configuration
public class MybatisPlusMultiDataSourceConfig {

    @Bean
    @Primary
    public SqlSessionFactory primarySqlSessionFactory(
            @Qualifier("primaryDataSource") DataSource dataSource) throws Exception {
        MybatisSqlSessionFactoryBean factory = new MybatisSqlSessionFactoryBean();
        factory.setDataSource(dataSource);
        factory.setMapperLocations(new PathMatchingResourcePatternResolver()
            .getResources("classpath:mapper/primary/**/*.xml"));
        return factory.getObject();
    }

    @Bean
    public SqlSessionFactory secondarySqlSessionFactory(
            @Qualifier("secondaryDataSource") DataSource dataSource) throws Exception {
        MybatisSqlSessionFactoryBean factory = new MybatisSqlSessionFactoryBean();
        factory.setDataSource(dataSource);
        factory.setMapperLocations(new PathMatchingResourcePatternResolver()
            .getResources("classpath:mapper/secondary/**/*.xml"));
        return factory.getObject();
    }
}

// 动态数据源上下文持有者
public class DynamicDataSourceContextHolder {

    private static final ThreadLocal<String> CONTEXT_HOLDER = new ThreadLocal<>();

    // 设置当前数据源标识
    public static void setDataSourceKey(String key) {
        CONTEXT_HOLDER.set(key);
    }

    // 获取当前数据源标识
    public static String getDataSourceKey() {
        return CONTEXT_HOLDER.get();
    }

    // 清除数据源标识
    public static void clearDataSourceKey() {
        CONTEXT_HOLDER.remove();
    }
}

// 动态数据源实现
public class DynamicDataSource extends AbstractRoutingDataSource {

    @Override
    protected Object determineCurrentLookupKey() {
        return DynamicDataSourceContextHolder.getDataSourceKey();
    }
}

// 动态数据源配置
@Configuration
public class DynamicDataSourceConfig {

    @Bean
    public DataSource dynamicDataSource(
            @Qualifier("primaryDataSource") DataSource primaryDataSource,
            @Qualifier("secondaryDataSource") DataSource secondaryDataSource) {
        
        DynamicDataSource dynamicDataSource = new DynamicDataSource();
        
        Map<Object, Object> targetDataSources = new HashMap<>();
        targetDataSources.put("primary", primaryDataSource);
        targetDataSources.put("secondary", secondaryDataSource);
        
        dynamicDataSource.setTargetDataSources(targetDataSources);
        dynamicDataSource.setDefaultTargetDataSource(primaryDataSource);
        
        return dynamicDataSource;
    }
}

// 自定义注解标记数据源
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DataSource {
    String value() default "primary";
}

// AOP 切面实现数据源切换
@Aspect
@Component
@Order(Ordered.HIGHEST_PRECEDENCE)  // 确保在事务切面之前执行
public class DataSourceAspect {

    @Around("@annotation(dataSource)")
    public Object around(ProceedingJoinPoint point, DataSource dataSource) throws Throwable {
        String key = dataSource.value();
        try {
            DynamicDataSourceContextHolder.setDataSourceKey(key);
            return point.proceed();
        } finally {
            DynamicDataSourceContextHolder.clearDataSourceKey();
        }
    }
}

// 使用示例
@Service
public class UserService {

    @DataSource("primary")
    public User findById(Long id) {
        // 使用主数据源查询
        return userMapper.selectById(id);
    }

    @DataSource("secondary")
    public List<User> findLogs(Long userId) {
        // 使用从数据源查询日志
        return logMapper.selectByUserId(userId);
    }
}

// @EnableJpaRepositories 触发 Repository 初始化
// JpaRepositoryFactoryBean 创建 Repository 代理
public class JpaRepositoryFactoryBean<T extends Repository<S, ID>, S, ID>
    extends TransactionalRepositoryFactoryBeanSupport<T, S, ID> {

    @Override
    protected RepositoryFactorySupport doCreateRepositoryFactory() {
        return new JpaRepositoryFactory(entityManager);
    }
}

// SimpleJpaRepository 是所有 JPA Repository 的默认实现
@Repository
@Transactional(readOnly = true)
public class SimpleJpaRepository<T, ID> implements JpaRepositoryImplementation<T, ID> {

    @Override
    public Optional<T> findById(ID id) {
        return em.find(domainClass, id) != null ? Optional.of(entity) : Optional.empty();
    }

    @Override
    @Transactional
    public <S extends T> S save(S entity) {
        if (entityInformation.isNew(entity)) {
            em.persist(entity);  // 新增
            return entity;
        } else {
            return em.merge(entity);  // 更新
        }
    }
}

// Entity 生命周期回调示例
@Entity
@Table(name = "t_user")
@EntityListeners(AuditingEntityListener.class)  // JPA 审计监听器
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String username;

    // 生命周期回调方法
    @PrePersist  // 持久化之前（INSERT 之前）
    private void prePersist() {
        System.out.println("即将插入用户：" + username);
    }

    @PostPersist  // 持久化之后（INSERT 之后，已有主键）
    private void postPersist() {
        System.out.println("用户已插入，ID=" + id);
    }

    @PreUpdate  // 更新之前（UPDATE 之前）
    private void preUpdate() {
        System.out.println("即将更新用户：" + username);
    }

    @PostUpdate  // 更新之后（UPDATE 之后）
    private void postUpdate() {
        System.out.println("用户已更新");
    }

    @PreRemove  // 删除之前（DELETE 之前）
    private void preRemove() {
        System.out.println("即将删除用户：" + id);
    }

    @PostRemove  // 删除之后（DELETE 之后）
    private void postRemove() {
        System.out.println("用户已删除");
    }

    @PostLoad  // 加载之后（SELECT 之后）
    private void postLoad() {
        System.out.println("用户已加载：" + username);
    }
}

// 1. 启用 JPA 审计
@Configuration
@EnableJpaAuditing(auditorAwareRef = "auditorAware")
public class JpaAuditingConfig {}

// 2. 实现 AuditorAware 接口，提供当前操作人
@Component
public class SpringSecurityAuditorAware implements AuditorAware<String> {

    @Override
    public Optional<String> getCurrentAuditor() {
        // 从 Spring Security 上下文获取当前用户
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        if (authentication == null || !authentication.isAuthenticated()) {
            return Optional.of("system");  // 系统自动操作
        }
        return Optional.of(authentication.getName());
    }
}

// 3. 审计基类——所有实体继承此类即可获得审计功能
@MappedSuperclass
@EntityListeners(AuditingEntityListener.class)
public abstract class BaseEntity {

    @CreatedDate  // 创建时间
    @Column(name = "created_at", updatable = false)
    private LocalDateTime createdAt;

    @LastModifiedDate  // 最后修改时间
    @Column(name = "updated_at")
    private LocalDateTime updatedAt;

    @CreatedBy  // 创建人
    @Column(name = "created_by", updatable = false, length = 50)
    private String createdBy;

    @LastModifiedBy  // 最后修改人
    @Column(name = "updated_by", length = 50)
    private String updatedBy;
}

// 4. 实体继承审计基类
@Entity
@Table(name = "t_order")
public class Order extends BaseEntity {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String orderNo;
    private BigDecimal amount;
}

public interface UserRepository extends JpaRepository<User, Long> {

    // 1. JPQL 查询（面向对象，使用实体类名和属性名）
    @Query("SELECT u FROM User u WHERE u.username = :username")
    Optional<User> findByUsername(@Param("username") String username);

    // 2. 原生 SQL 查询（nativeQuery = true）
    @Query(value = "SELECT * FROM t_user WHERE DATE(created_at) = :date", nativeQuery = true)
    List<User> findByCreatedDate(@Param("date") LocalDate date);

    // 3. 更新操作（必须加 @Modifying + @Transactional）
    @Modifying
    @Transactional
    @Query("UPDATE User u SET u.status = :status WHERE u.id IN :ids")
    int batchUpdateStatus(@Param("status") Integer status, @Param("ids") List<Long> ids);

    // 4. 删除操作
    @Modifying
    @Transactional
    @Query("DELETE FROM User u WHERE u.lastLoginAt < :expireDate")
    int deleteInactiveUsers(@Param("expireDate") LocalDateTime expireDate);

    // 5. 联表查询 + DTO 投影
    @Query("SELECT new com.example.dto.UserOrderDTO(u.username, COUNT(o.id), SUM(o.amount)) " +
           "FROM User u LEFT JOIN u.orders o " +
           "GROUP BY u.username " +
           "HAVING SUM(o.amount) > :minAmount")
    List<UserOrderDTO> findUserOrderStats(@Param("minAmount") BigDecimal minAmount);

    // 6. 使用 SpEL 表达式引用实体类名
    @Query("SELECT e FROM #{#entityName} e WHERE e.deleted = false")
    List<User> findAllActive();

    // 7. LIKE 模糊查询——注意拼接方式
    @Query("SELECT u FROM User u WHERE u.username LIKE CONCAT('%', :keyword, '%')")
    List<User> searchByKeyword(@Param("keyword") String keyword);
}

// 1. 实现 Specification 接口
public class UserSpecs {

    // 用户名模糊查询
    public static Specification<User> usernameLike(String username) {
        return (root, query, cb) ->
            StringUtils.isBlank(username) ? null :
            cb.like(root.get("username"), "%" + username + "%");
    }

    // 状态精确匹配
    public static Specification<User> statusEqual(Integer status) {
        return (root, query, cb) ->
            status == null ? null : cb.equal(root.get("status"), status);
    }

    // 创建时间范围查询
    public static Specification<User> createdAtBetween(LocalDateTime start, LocalDateTime end) {
        return (root, query, cb) ->
            start == null || end == null ? null :
            cb.between(root.get("createdAt"), start, end);
    }

    // 关联查询：订单金额大于指定值
    public static Specification<User> hasOrderAmountGreaterThan(BigDecimal amount) {
        return (root, query, cb) -> {
            Join<User, Order> orderJoin = root.join("orders", JoinType.INNER);
            return cb.greaterThan(orderJoin.get("amount"), amount);
        };
    }
}

// 2. Repository 继承 JpaSpecificationExecutor
public interface UserRepository extends JpaRepository<User, Long>,
        JpaSpecificationExecutor<User> {
}

// 3. Service 层组合动态查询
@Service
@RequiredArgsConstructor
public class UserService {

    private final UserRepository userRepository;

    public Page<User> search(UserQueryDTO queryDTO, Pageable pageable) {
        // 动态组合查询条件
        Specification<User> spec = Specification
            .where(UserSpecs.usernameLike(queryDTO.getUsername()))
            .and(UserSpecs.statusEqual(queryDTO.getStatus()))
            .and(UserSpecs.createdAtBetween(queryDTO.getStartTime(), queryDTO.getEndTime()));

        return userRepository.findAll(spec, pageable);
    }
}

// 1. 基于接口的投影（动态代理实现）
public interface UserSummary {
    Long getId();
    String getUsername();
    String getEmail();

    // 支持 SpEL 表达式计算派生值
    @Value("#{target.username + ' <' + target.email + '>'}")
    String getDisplayName();
}

public interface UserRepository extends JpaRepository<User, Long> {
    // 返回接口投影
    List<UserSummary> findByStatus(Integer status);

    // 基于 @Query 的投影
    @Query("SELECT u.id AS id, u.username AS username FROM User u WHERE u.deleted = false")
    List<UserSummary> findActiveUserSummaries();
}

// 2. 基于类的投影（DTO）
public record UserOrderCountDTO(String username, Long orderCount) {}

@Query("SELECT new com.example.dto.UserOrderCountDTO(u.username, COUNT(o.id)) " +
       "FROM User u LEFT JOIN u.orders o GROUP BY u.username")
List<UserOrderCountDTO> findUserOrderCounts();

// 3. 基于记录类（Java 16+ Record）的投影
public record UserBriefProjection(Long id, String username, LocalDateTime createdAt) {}

List<UserBriefProjection> findAllProjectedBy();

// 1. 定义自定义 Repository 接口
public interface CustomUserRepository {
    // 批量插入（使用 JDBC 批处理提升性能）
    void batchInsert(List<User> users);

    // 复杂统计查询
    UserStatisticsDTO getUserStatistics(Long userId);
}

// 2. 实现自定义 Repository
public class CustomUserRepositoryImpl implements CustomUserRepository {

    @PersistenceContext
    private EntityManager entityManager;

    @Override
    @Transactional
    public void batchInsert(List<User> users) {
        for (int i = 0; i < users.size(); i++) {
            entityManager.persist(users.get(i));
            // 每 50 条 flush 一次，避免内存溢出
            if (i % 50 == 0) {
                entityManager.flush();
                entityManager.clear();  // 清除持久化上下文，释放内存
            }
        }
    }

    @Override
    public UserStatisticsDTO getUserStatistics(Long userId) {
        // 使用原生 SQL 执行复杂统计
        Query query = entityManager.createNativeQuery(
            "SELECT COUNT(*) AS order_count, SUM(amount) AS total_amount " +
            "FROM t_order WHERE user_id = :userId"
        );
        query.setParameter("userId", userId);
        Object[] row = (Object[]) query.getSingleResult();
        return new UserStatisticsDTO(
            ((Number) row[0]).longValue(),
            (BigDecimal) row[1]
        );
    }
}

// 3. 让 Repository 接口继承自定义接口
public interface UserRepository extends JpaRepository<User, Long>,
        JpaSpecificationExecutor<User>,
        CustomUserRepository {  // 继承自定义接口
    // Spring Data JPA 会自动将 CustomUserRepositoryImpl 的方法
    // 合并到 UserRepository 的代理中
}

// × N+1 问题：查询 N 个用户，每个用户触发 1 次订单查询
@GetMapping("/users")
public List<User> getUsers() {
    List<User> users = userRepository.findAll();  // 1 次查询
    // 延迟加载 orders，每个用户触发 1 次查询 = N 次查询
    users.forEach(u -> u.getOrders().size());  // N 次查询！
    return users;
}

// √ 方式1：JOIN FETCH 一次性加载
@Query("SELECT u FROM User u LEFT JOIN FETCH u.orders")
List<User> findAllWithOrders();

// √ 方式2：@EntityGraph 声明式加载
@EntityGraph(attributePaths = "orders")
List<User> findAll();

// √ 方式3：@NamedEntityGraph 在实体上定义
@NamedEntityGraph(
    name = "User.withOrders",
    attributeNodes = @NamedAttributeNode("orders")
)
@Entity
public class User { ... }

// 在 Repository 中引用
@EntityGraph(value = "User.withOrders", type = EntityGraphType.LOAD)
List<User> findAll();

// √ 方式4：关闭 OSIV + 在 Service 层完成加载

// Spring 通过 AOP 代理实现声明式事务
// TransactionInterceptor 拦截 @Transactional 方法
public class TransactionInterceptor extends TransactionAspectSupport
    implements MethodInterceptor {

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        // 获取事务属性
        TransactionAttributeSource tas = getTransactionAttributeSource();
        TransactionAttribute txAttr = tas.getTransactionAttribute(method, targetClass);

        // 获取 PlatformTransactionManager
        PlatformTransactionManager tm = determineTransactionManager(txAttr);

        // 创建事务
        TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);

        try {
            // 执行目标方法
            Object retVal = invocation.proceedWithInvocation();
            return retVal;
        } catch (Throwable ex) {
            // 异常回滚
            completeTransactionAfterThrowing(txInfo, ex);
            throw ex;
        } finally {
            cleanupTransactionInfo(txInfo);
        }
    }
}

// AbstractPlatformTransactionManager.handleExistingTransaction() 核心逻辑
// 当传播行为为 REQUIRED 且当前已有事务时
if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED) {
    // 直接加入当前事务，不做任何处理
    return new TransactionStatusForExistingTransaction(
        transaction, null, newSynchronization, debugEnabled, null
    );
}

// 当传播行为为 REQUIRED 且当前无事务时
// 在 getTransaction() 中会创建新事务
if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED) {
    // 启动新事务
    doBegin(transaction, definition);
    // ... 注册同步回调
}

// REQUIRES_NEW：总是新建独立事务，挂起当前事务
if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW) {
    // 挂起当前事务
    SuspendedResourcesHolder suspendedResources = suspend(transaction);
    try {
        // 创建新事务
        boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
        DefaultTransactionStatus status = newTransactionStatus(
            definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
        doBegin(transaction, definition);
        prepareSynchronization(status, definition);
        return status;
    } catch (RuntimeException | Error ex) {
        // 新事务创建失败，恢复挂起的事务
        resume(transaction, suspendedResources);
        throw ex;
    }
}

// NESTED：在当前事务中创建 savepoint
if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
    // 检查是否支持 savepoint
    if (!isNestedTransactionAllowed()) {
        throw new NestedTransactionNotSupportedException(
            "Nested transaction not supported");
    }
    // 使用 savepoint 实现嵌套
    if (useSavepointForNestedTransaction()) {
        // 在当前事务中创建 savepoint
        SavepointManager savepointManager = getSavepointManager(transaction);
        Object savepoint = savepointManager.createSavepoint();
        return new DefaultTransactionStatus(
            transaction, false, false, newSynchronization, debugEnabled, savepoint);
    }
}

// NESTED vs REQUIRES_NEW 的区别
@Service
public class OrderService {

    // NESTED：内层事务回滚不影响外层（通过 savepoint）
    @Transactional
    public void createOrder() {
        orderMapper.insert(order);
        try {
            this.saveLog();  // NESTED 传播
        } catch (Exception e) {
            // 日志保存失败，只回滚到 savepoint，订单不受影响
        }
    }

    @Transactional(propagation = Propagation.NESTED)
    public void saveLog() {
        logMapper.insert(log);
        // 如果这里抛出异常，只回滚到 savepoint
    }
}

// Spring 中设置隔离级别
@Transactional(isolation = Isolation.REPEATABLE_READ)
public User findById(Long id) {
    return userMapper.selectById(id);
}

// AbstractPlatformTransactionManager 中隔离级别的处理
protected DefaultTransactionStatus startTransaction(
        TransactionDefinition definition, Object transaction,
        boolean newSynchronization, boolean debugEnabled) {
    
    // 根据隔离级别设置数据库连接的隔离级别
    if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT) {
        doSetIsolationLevel(transaction, definition.getIsolationLevel());
    }
    // ...
}

// 事务超时设置（单位：秒）
@Transactional(timeout = 30)  // 30 秒超时
public void processOrder(Long orderId) {
    // 如果 30 秒内未完成，事务自动回滚
    orderMapper.updateStatus(orderId, "PROCESSING");
    // ... 耗时操作
}

// TransactionTemplate 编程式事务超时
TransactionTemplate txTemplate = new TransactionTemplate(transactionManager);
txTemplate.setTimeout(30);  // 30 秒超时
txTemplate.execute(status -> {
    // 事务操作
    return result;
});

@Service
public class OrderService {
    // × 外部调用 createOrder() 有事务，但内部调用 deductStock() 不走代理
    @Transactional
    public void createOrder(OrderDTO dto) {
        orderMapper.insert(dto);
        this.deductStock(dto.getProductId());  // 不走代理，事务不生效！
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void deductStock(Long productId) {
        // 期望独立事务，但实际没有
    }
}

// √ 方式1：自注入代理
@Service
@RequiredArgsConstructor
public class OrderService {
    private final OrderService self;  // 代理对象

    @Transactional
    public void createOrder(OrderDTO dto) {
        orderMapper.insert(dto);
        self.deductStock(dto.getProductId());  // 走代理
    }
}

// √ 方式2：提取到另一个 Service
@Service
@RequiredArgsConstructor
public class OrderService {
    private final StockService stockService;

    @Transactional
    public void createOrder(OrderDTO dto) {
        orderMapper.insert(dto);
        stockService.deductStock(dto.getProductId());  // 走代理
    }
}

@Service
public class OrderService {

    // × 异常被 catch，事务不会回滚
    @Transactional
    public void createOrder(OrderDTO dto) {
        try {
            orderMapper.insert(dto);
            stockService.deductStock(dto.getProductId());
        } catch (Exception e) {
            log.error("创建订单失败", e);
            // 异常被吞掉，事务不会回滚！
        }
    }

    // √ 方式1：catch 后重新抛出
    @Transactional
    public void createOrder(OrderDTO dto) {
        try {
            orderMapper.insert(dto);
            stockService.deductStock(dto.getProductId());
        } catch (Exception e) {
            log.error("创建订单失败", e);
            throw e;  // 重新抛出，触发回滚
        }
    }

    // √ 方式2：手动标记回滚
    @Transactional
    public void createOrder(OrderDTO dto) {
        try {
            orderMapper.insert(dto);
            stockService.deductStock(dto.getProductId());
        } catch (Exception e) {
            log.error("创建订单失败", e);
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        }
    }
}

@Service
public class OrderService {

    // × 默认只回滚 RuntimeException 和 Error，不回滚 checked Exception
    @Transactional
    public void createOrder(OrderDTO dto) throws IOException {
        orderMapper.insert(dto);
        throw new IOException("文件写入失败");  // 不会回滚！
    }

    // √ 指定 rollbackFor = Exception.class，所有异常都回滚
    @Transactional(rollbackFor = Exception.class)
    public void createOrder(OrderDTO dto) throws IOException {
        orderMapper.insert(dto);
        throw new IOException("文件写入失败");  // 会回滚
    }
}

@Service
public class OrderService {

    // × 多线程中事务不共享
    @Transactional
    public void batchProcess(List<Long> orderIds) {
        orderIds.parallelStream().forEach(id -> {
            // 每个线程获取不同的数据库连接，不在同一事务中
            orderMapper.updateStatus(id, "PROCESSED");
        });
    }

    // √ 使用编程式事务管理
    @Autowired
    private PlatformTransactionManager transactionManager;

    public void batchProcess(List<Long> orderIds) {
        orderIds.forEach(id -> {
            TransactionTemplate txTemplate = new TransactionTemplate(transactionManager);
            txTemplate.execute(status -> {
                orderMapper.updateStatus(id, "PROCESSED");
                return null;
            });
        });
    }
}

// MybatisPlusAutoConfiguration.java
@Configuration
@ConditionalOnClass({SqlSessionFactory.class, SqlSessionFactoryBean.class})
@EnableConfigurationProperties(MybatisPlusProperties.class)
@AutoConfigureAfter({DataSourceAutoConfiguration.class})
public class MybatisPlusAutoConfiguration {

    @Bean
    @ConditionalOnMissingBean
    public SqlSessionFactory sqlSessionFactory(DataSource dataSource,
                                                MybatisPlusProperties properties) throws Exception {
        MybatisSqlSessionFactoryBean factory = new MybatisSqlSessionFactoryBean();
        factory.setDataSource(dataSource);
        factory.setConfiguration(properties.getConfiguration());
        factory.setPlugins(properties.getPlugins());  // 注册插件
        return factory.getObject();
    }
}

@Mapper
public interface UserMapper extends BaseMapper<User> {
    // 自动拥有：insert / deleteById / updateById / selectById / selectList / selectPage
}

// 条件构造器示例
@Service
@RequiredArgsConstructor
public class UserService {
    private final UserMapper userMapper;

    public List<User> searchUsers(String name, String status) {
        LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
        wrapper.like(StringUtils.isNotBlank(name), User::getUsername, name)
               .eq(StringUtils.isNotBlank(status), User::getStatus, status)
               .orderByDesc(User::getCreatedAt);
        return userMapper.selectList(wrapper);
    }
}

// 分页插件配置
@Configuration
public class MybatisPlusConfig {

    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        // 添加分页插件，指定数据库类型
        interceptor.addInnerInterceptor(
            new PaginationInnerInterceptor(DbType.MYSQL)
        );
        return interceptor;
    }
}

// 分页查询使用示例
@Service
@RequiredArgsConstructor
public class UserService {

    private final UserMapper userMapper;

    // 基础分页查询
    public IPage<User> pageQuery(int pageNum, int pageSize, String keyword) {
        Page<User> page = new Page<>(pageNum, pageSize);
        LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
        wrapper.like(StringUtils.isNotBlank(keyword), User::getUsername, keyword)
               .orderByDesc(User::getCreatedAt);
        return userMapper.selectPage(page, wrapper);
    }

    // 自定义 SQL 分页查询
    // UserMapper.java
    @Select("SELECT u.*, d.name AS dept_name FROM t_user u " +
            "LEFT JOIN t_dept d ON u.dept_id = d.id " +
            "WHERE u.status = #{status}")
    IPage<UserVO> selectUserVOPage(
        Page<UserVO> page,  // MyBatis-Plus 自动处理分页参数
        @Param("status") Integer status
    );
}

// Controller 层分页响应封装
@GetMapping("/users")
public Result<PageResult<UserVO>> listUsers(
        @RequestParam(defaultValue = "1") Integer pageNum,
        @RequestParam(defaultValue = "10") Integer pageSize,
        @RequestParam(required = false) String keyword) {
    
    IPage<User> page = userService.pageQuery(pageNum, pageSize, keyword);
    
    PageResult<UserVO> result = new PageResult<>();
    result.setList(BeanUtil.copyToList(page.getRecords(), UserVO.class));
    result.setTotal(page.getTotal());
    result.setPageNum(page.getCurrent());
    result.setPageSize(page.getSize());
    
    return Result.success(result);
}

// 1. 配置乐观锁插件
@Configuration
public class MybatisPlusConfig {

    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());  // 乐观锁
        return interceptor;
    }
}

// 2. 实体类添加 @Version 字段
@Data
@TableName("t_product")
public class Product {
    @TableId
    private Long id;

    private String name;
    private BigDecimal price;
    private Integer stock;

    @Version  // 乐观锁版本号
    private Integer version;
}

// 3. 使用乐观锁更新
@Service
@RequiredArgsConstructor
public class ProductService {

    private final ProductMapper productMapper;

    @Transactional
    public boolean deductStock(Long productId, Integer quantity) {
        // 先查询获取当前版本号
        Product product = productMapper.selectById(productId);
        if (product.getStock() < quantity) {
            throw new BusinessException("库存不足");
        }
        
        // 设置扣减数量，MyBatis-Plus 自动在 UPDATE 中添加 version 条件
        product.setStock(product.getStock() - quantity);
        int rows = productMapper.updateById(product);
        // 生成的 SQL：UPDATE t_product SET stock=?, version=version+1 
        //            WHERE id=? AND version=原版本号
        
        if (rows == 0) {
            // 版本号不匹配，说明已被其他线程修改
            throw new BusinessException("并发冲突，请重试");
        }
        return true;
    }
}

// 1. 全局配置逻辑删除
// application.yml
mybatis-plus:
  global-config:
    db-config:
      logic-delete-field: deleted    # 全局逻辑删除字段名
      logic-delete-value: 1          # 删除值
      logic-not-delete-value: 0      # 未删除值

// 2. 实体类添加逻辑删除字段
@Data
@TableName("t_user")
public class User {
    @TableId
    private Long id;

    private String username;

    @TableLogic  // 逻辑删除字段
    private Integer deleted;
}

// 3. 使用效果
// deleteById() → UPDATE t_user SET deleted=1 WHERE id=? AND deleted=0
// selectById() → SELECT * FROM t_user WHERE id=? AND deleted=0
// selectList() → SELECT * FROM t_user WHERE deleted=0

// 1. 实体类标注填充策略
@Data
@TableName("t_user")
public class User {
    @TableId
    private Long id;

    private String username;

    @TableField(fill = FieldFill.INSERT)  // 插入时填充
    private LocalDateTime createTime;

    @TableField(fill = FieldFill.INSERT_UPDATE)  // 插入和更新时填充
    private LocalDateTime updateTime;

    @TableField(fill = FieldFill.INSERT)  // 插入时填充
    private String createBy;

    @TableField(fill = FieldFill.INSERT_UPDATE)  // 插入和更新时填充
    private String updateBy;
}

// 2. 实现 MetaObjectHandler 接口
@Component
public class MyMetaObjectHandler implements MetaObjectHandler {

    @Override
    public void insertFill(MetaObject metaObject) {
        this.strictInsertFill(metaObject, "createTime", LocalDateTime.class, LocalDateTime.now());
        this.strictInsertFill(metaObject, "updateTime", LocalDateTime.class, LocalDateTime.now());
        this.strictInsertFill(metaObject, "createBy", String.class, getCurrentUser());
        this.strictInsertFill(metaObject, "updateBy", String.class, getCurrentUser());
    }

    @Override
    public void updateFill(MetaObject metaObject) {
        this.strictUpdateFill(metaObject, "updateTime", LocalDateTime.class, LocalDateTime.now());
        this.strictUpdateFill(metaObject, "updateBy", String.class, getCurrentUser());
    }

    private String getCurrentUser() {
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        return auth != null ? auth.getName() : "system";
    }
}

// 1. 实现 TenantLineHandler 接口
@Component
public class CustomTenantHandler implements TenantLineHandler {

    // 获取当前租户 ID
    @Override
    public Expression getTenantId() {
        Long tenantId = TenantContextHolder.getTenantId();
        return new LongValue(tenantId != null ? tenantId : 0);
    }

    // 获取租户字段名
    @Override
    public String getTenantIdColumn() {
        return "tenant_id";
    }

    // 判断哪张表不需要租户隔离
    @Override
    public boolean ignoreTable(String tableName) {
        // 系统表不需要租户隔离
        return "sys_config".equals(tableName) ||
               "sys_dict".equals(tableName);
    }
}

// 2. 配置多租户插件
@Configuration
public class MybatisPlusConfig {

    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor(
            CustomTenantHandler tenantHandler) {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        // 多租户插件必须放在最前面
        interceptor.addInnerInterceptor(new TenantLineInnerInterceptor(tenantHandler));
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
        return interceptor;
    }
}

// 3. 租户上下文
public class TenantContextHolder {
    private static final ThreadLocal<Long> TENANT_ID = new ThreadLocal<>();

    public static void setTenantId(Long tenantId) {
        TENANT_ID.set(tenantId);
    }

    public static Long getTenantId() {
        return TENANT_ID.get();
    }

    public static void clear() {
        TENANT_ID.remove();
    }
}

// 使用效果
// 原始 SQL：SELECT * FROM t_user WHERE id = 1
// 自动追加租户条件后：SELECT * FROM t_user WHERE id = 1 AND tenant_id = 100

// INSERT 也会自动追加租户 ID
// 原始 SQL：INSERT INTO t_user (username, age) VALUES ('张三', 25)
// 自动追加后：INSERT INTO t_user (username, age, tenant_id) VALUES ('张三', 25, 100)

// 代码生成器配置（MyBatis-Plus 3.5.x 新版 API）
public class CodeGenerator {

    public static void main(String[] args) {
        // 数据源配置
        DataSourceConfig.Builder dataSourceConfig = new DataSourceConfig.Builder(
            "jdbc:mysql://localhost:3306/my_db",
            "root",
            "root123"
        );

        // 全局配置
        GlobalConfig globalConfig = new GlobalConfig.Builder()
            .outputDir(System.getProperty("user.dir") + "/src/main/java")
            .author("generator")
            .enableSwagger()  // 开启 Swagger 注解
            .dateType(DateType.TIME_PACK)  // 使用 LocalDateTime
            .build();

        // 包配置
        PackageConfig packageConfig = new PackageConfig.Builder()
            .parent("com.example")
            .moduleName("system")
            .entity("entity")
            .mapper("mapper")
            .service("service")
            .serviceImpl("service.impl")
            .controller("controller")
            .build();

        // 策略配置
        StrategyConfig strategyConfig = new StrategyConfig.Builder()
            .addInclude("t_user", "t_order", "t_product")  // 要生成的表
            .addTablePrefix("t_")  // 表名前缀，生成时去除
            .entityBuilder()
                .enableLombok()  // 使用 Lombok
                .enableTableFieldAnnotation()  // 所有字段加 @TableField
                .logicDeleteColumnName("deleted")  // 逻辑删除字段
                .versionColumnName("version")  // 乐观锁字段
                .addTableFills(
                    new Column("create_time", FieldFill.INSERT),
                    new Column("update_time", FieldFill.INSERT_UPDATE)
                )
            .mapperBuilder()
                .enableMapperAnnotation()  // 添加 @Mapper 注解
                .enableBaseResultMap()  // 生成 BaseResultMap
            .serviceBuilder()
                .formatServiceFileName("%sService")  // 不加 I 前缀
            .controllerBuilder()
                .enableRestStyle()  // @RestController
            .build();

        // 执行生成
        AutoGenerator generator = new AutoGenerator(dataSourceConfig)
            .global(globalConfig)
            .packageInfo(packageConfig)
            .strategy(strategyConfig)
            .templateEngine(new FreemarkerTemplateEngine());  // 使用 Freemarker 模板

        generator.execute();
    }
}

spring:
  datasource:
    hikari:
      maximum-pool-size: 20            # 最大连接数
      minimum-idle: 5                   # 最小空闲连接数
      connection-timeout: 30000         # 获取连接超时（ms）
      idle-timeout: 600000              # 空闲连接超时（ms）
      max-lifetime: 1800000             # 连接最大存活时间（ms）
      leak-detection-threshold: 60000   # 连接泄漏检测阈值（ms）
      pool-name: MyHikariCP             # 连接池名称，便于监控
      connection-test-query: SELECT 1   # 连接测试语句
      validation-timeout: 5000          # 连接验证超时（ms）

// HikariCP 获取连接的核心流程
public class HikariPool extends PoolBase implements HikariPoolMXBean, IBagStateTarget {

    // ConcurrentBag：无锁连接池
    private final ConcurrentBag<HikariProxyConnection> connectionBag;

    // 获取连接
    public Connection getConnection(final long hardTimeout) throws SQLException {
        long startTime = currentTime();
        long timeout = hardTimeout;
        do {
            // 1. 从 ThreadLocal 获取连接（最快路径）
            HikariProxyConnection connection = connectionBag.borrow(timeout, MILLISECONDS);
            if (connection == null) {
                break;  // 超时
            }
            // 2. 检查连接是否存活
            if (!connection.isMarkedEvicted() && isConnectionAlive(connection)) {
                return connection;  // 返回可用连接
            }
            // 3. 连接已失效，关闭并重试
            closeConnection(connection);
            timeout = hardTimeout - elapsedMillis(startTime);
        } while (timeout > 0L);
        
        // 超时抛出异常
        throw new SQLTransientConnectionException(
            "Connection is not available, request timed out after " + elapsedMillis(startTime) + "ms.");
    }
}

// ConcurrentBag：无锁并发容器
public class ConcurrentBag<T extends IConcurrentBagEntry> implements AutoCloseable {

    // ThreadLocal 缓存：每个线程优先从自己的列表获取连接
    private final ThreadLocal<List<Object>> threadList;

    // 分享队列：其他线程归还的连接
    private final CopyOnWriteArrayList<T> sharedList;

    public T borrow(long timeout, final TimeUnit timeUnit) {
        // 1. 优先从 ThreadLocal 获取（无锁）
        List<Object> list = threadList.get();
        for (int i = list.size() - 1; i >= 0; i--) {
            Object entry = list.remove(i);
            if (CAS((T) entry, STATE_NOT_IN_USE, STATE_IN_USE)) {
                return (T) entry;
            }
        }
        // 2. 从 sharedList 获取（CAS 无锁）
        for (T entry : sharedList) {
            if (CAS(entry, STATE_NOT_IN_USE, STATE_IN_USE)) {
                return entry;
            }
        }
        // 3. 等待其他线程归还连接
        listener.addBagEntry(waiter);
        timeout = timeUnit.toNanos(timeout);
        do {
            // ... 等待逻辑
        } while (timeout > 0);
        return null;
    }
}

// Spring Boot 自动配置 JdbcTemplate
// 只需引入 spring-boot-starter-jdbc 依赖即可
@Service
@RequiredArgsConstructor
public class UserJdbcService {

    private final JdbcTemplate jdbcTemplate;

    // 查询列表
    public List<User> findAll() {
        String sql = "SELECT id, username, email, status FROM t_user WHERE deleted = 0";
        return jdbcTemplate.query(sql, (rs, rowNum) -> {
            User user = new User();
            user.setId(rs.getLong("id"));
            user.setUsername(rs.getString("username"));
            user.setEmail(rs.getString("email"));
            user.setStatus(rs.getInt("status"));
            return user;
        });
    }

    // 查询单条记录
    public User findById(Long id) {
        String sql = "SELECT id, username, email, status FROM t_user WHERE id = ? AND deleted = 0";
        return jdbcTemplate.queryForObject(sql, new UserRowMapper(), id);
    }

    // 查询统计值
    public int countByStatus(Integer status) {
        String sql = "SELECT COUNT(*) FROM t_user WHERE status = ? AND deleted = 0";
        return jdbcTemplate.queryForObject(sql, Integer.class, status);
    }

    // 插入数据
    public int insert(User user) {
        String sql = "INSERT INTO t_user (username, email, status) VALUES (?, ?, ?)";
        return jdbcTemplate.update(sql, user.getUsername(), user.getEmail(), user.getStatus());
    }

    // 插入并获取自增主键
    public Long insertAndGetId(User user) {
        String sql = "INSERT INTO t_user (username, email, status) VALUES (?, ?, ?)";
        KeyHolder keyHolder = new GeneratedKeyHolder();
        jdbcTemplate.update(connection -> {
            PreparedStatement ps = connection.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
            ps.setString(1, user.getUsername());
            ps.setString(2, user.getEmail());
            ps.setInt(3, user.getStatus());
            return ps;
        }, keyHolder);
        return keyHolder.getKey().longValue();
    }

    // 更新数据
    public int update(Long id, String email) {
        String sql = "UPDATE t_user SET email = ? WHERE id = ?";
        return jdbcTemplate.update(sql, email, id);
    }

    // 删除数据
    public int deleteById(Long id) {
        String sql = "UPDATE t_user SET deleted = 1 WHERE id = ?";
        return jdbcTemplate.update(sql, id);
    }
}

// RowMapper 实现
public class UserRowMapper implements RowMapper<User> {
    @Override
    public User mapRow(ResultSet rs, int rowNum) throws SQLException {
        User user = new User();
        user.setId(rs.getLong("id"));
        user.setUsername(rs.getString("username"));
        user.setEmail(rs.getString("email"));
        user.setStatus(rs.getInt("status"));
        user.setCreatedAt(rs.getTimestamp("created_at").toLocalDateTime());
        return user;
    }
}

@Service
@RequiredArgsConstructor
public class BatchJdbcService {

    private final JdbcTemplate jdbcTemplate;

    // 批量插入
    public int[] batchInsert(List<User> users) {
        String sql = "INSERT INTO t_user (username, email, status) VALUES (?, ?, ?)";
        return jdbcTemplate.batchUpdate(sql, new BatchPreparedStatementSetter() {
            @Override
            public void setValues(PreparedStatement ps, int i) throws SQLException {
                User user = users.get(i);
                ps.setString(1, user.getUsername());
                ps.setString(2, user.getEmail());
                ps.setInt(3, user.getStatus());
            }

            @Override
            public int getBatchSize() {
                return users.size();
            }
        });
    }

    // 大批量插入（分片处理，避免内存溢出）
    public void largeBatchInsert(List<User> users) {
        int batchSize = 500;  // 每批 500 条
        jdbcTemplate.batchUpdate(
            "INSERT INTO t_user (username, email, status) VALUES (?, ?, ?)",
            users,  // 直接传入集合
            batchSize,
            (ps, user) -> {
                ps.setString(1, user.getUsername());
                ps.setString(2, user.getEmail());
                ps.setInt(3, user.getStatus());
            }
        );
    }
}

// NamedParameterJdbcTemplate 支持命名参数，可读性更好
@Service
@RequiredArgsConstructor
public class NamedParamJdbcService {

    private final NamedParameterJdbcTemplate namedTemplate;

    // 使用命名参数
    public User findByUsernameAndStatus(String username, Integer status) {
        String sql = "SELECT * FROM t_user WHERE username = :username AND status = :status";
        MapSqlParameterSource params = new MapSqlParameterSource()
            .addValue("username", username)
            .addValue("status", status);
        return namedTemplate.queryForObject(sql, params, new UserRowMapper());
    }

    // 使用 Bean 属性作为参数
    public List<User> findByCondition(UserQueryDTO queryDTO) {
        String sql = "SELECT * FROM t_user WHERE username LIKE :username " +
                     "AND status = :status AND created_at > :startTime";
        // BeanPropertySqlParameterSource 自动从 DTO 中提取属性值
        BeanPropertySqlParameterSource params = new BeanPropertySqlParameterSource(queryDTO);
        return namedTemplate.query(sql, params, new UserRowMapper());
    }

    // IN 查询
    public List<User> findByIds(List<Long> ids) {
        String sql = "SELECT * FROM t_user WHERE id IN (:ids)";
        MapSqlParameterSource params = new MapSqlParameterSource()
            .addValue("ids", ids);  // 自动展开为 ?, ?, ?
        return namedTemplate.query(sql, params, new UserRowMapper());
    }
}

// 1. 配置主从数据源
@Configuration
public class MasterSlaveDataSourceConfig {

    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.master")
    public DataSource masterDataSource() {
        return DataSourceBuilder.create().type(HikariDataSource.class).build();
    }

    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.slave")
    public DataSource slaveDataSource() {
        return DataSourceBuilder.create().type(HikariDataSource.class).build();
    }
}

// 2. 使用 dynamic-datasource-spring-boot-starter（推荐）
// 引入依赖
// <dependency>
//     <groupId>com.baomidou</groupId>
//     <artifactId>dynamic-datasource-spring-boot-starter</artifactId>
//     <version>4.3.0</version>
// </dependency>

// application.yml 配置
// spring:
//   datasource:
//     dynamic:
//       primary: master
//       strict: true  # 严格匹配，找不到数据源时报错
//       datasource:
//         master:
//           url: jdbc:mysql://localhost:3306/main_db
//           username: root
//           password: root123
//         slave_1:
//           url: jdbc:mysql://localhost:3307/main_db
//           username: root
//           password: root123
//         slave_2:
//           url: jdbc:mysql://localhost:3308/main_db
//           username: root
//           password: root123

// 3. 使用 @DS 注解切换数据源
@Service
@RequiredArgsConstructor
public class UserService {

    private final UserMapper userMapper;

    // 写操作走主库
    @DS("master")
    @Transactional
    public void createUser(User user) {
        userMapper.insert(user);
    }

    // 读操作走从库
    @DS("slave_1")
    public User findById(Long id) {
        return userMapper.selectById(id);
    }

    // 默认走主库（@DS 可以标注在类上作为默认值）
    public List<User> findAll() {
        return userMapper.selectList(null);
    }
}

// 4. 在 Mapper 层标注（更细粒度）
@Mapper
@DS("slave_1")  // 默认走从库
public interface UserMapper extends BaseMapper<User> {

    @DS("master")  // 写操作走主库
    int insert(User user);

    @DS("master")
    int updateById(User user);

    // 继承的方法默认走从库
}

// 自定义读写分离路由数据源
public class ReadWriteSplittingDataSource extends AbstractRoutingDataSource {

    private final DataSource masterDataSource;
    private final List<DataSource> slaveDataSources;
    private final AtomicInteger slaveIndex = new AtomicInteger(0);

    public ReadWriteSplittingDataSource(DataSource masterDataSource,
                                         List<DataSource> slaveDataSources) {
        this.masterDataSource = masterDataSource;
        this.slaveDataSources = slaveDataSources;
        
        Map<Object, Object> targetDataSources = new HashMap<>();
        targetDataSources.put("master", masterDataSource);
        for (int i = 0; i < slaveDataSources.size(); i++) {
            targetDataSources.put("slave_" + i, slaveDataSources.get(i));
        }
        
        this.setTargetDataSources(targetDataSources);
        this.setDefaultTargetDataSource(masterDataSource);
    }

    @Override
    protected Object determineCurrentLookupKey() {
        // 判断当前操作是读还是写
        // 通过 ThreadLocal 中的标记判断
        Boolean readOnly = ReadOnlyContextHolder.isReadOnly();
        if (readOnly != null && readOnly && !slaveDataSources.isEmpty()) {
            // 简单轮询负载均衡
            int index = slaveIndex.getAndIncrement() % slaveDataSources.size();
            return "slave_" + index;
        }
        return "master";
    }
}

// 只读上下文持有者
public class ReadOnlyContextHolder {
    private static final ThreadLocal<Boolean> READ_ONLY = new ThreadLocal<>();

    public static void setReadOnly(boolean readOnly) {
        READ_ONLY.set(readOnly);
    }

    public static Boolean isReadOnly() {
        return READ_ONLY.get();
    }

    public static void clear() {
        READ_ONLY.remove();
    }
}

// AOP 切面自动标记只读
@Aspect
@Component
@Order(Ordered.HIGHEST_PRECEDENCE)
public class ReadOnlyAspect {

    // 所有查询方法标记为只读
    @Before("execution(* com.example..service..find*(..)) || " +
            "execution(* com.example..service..get*(..)) || " +
            "execution(* com.example..service..query*(..)) || " +
            "execution(* com.example..service..list*(..)) || " +
            "execution(* com.example..service..count*(..))")
    public void setReadOnly() {
        ReadOnlyContextHolder.setReadOnly(true);
    }

    @After("execution(* com.example..service..*(..))")
    public void clearReadOnly() {
        ReadOnlyContextHolder.clear();
    }
}

## application.yml Druid 配置
spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    druid:
      url: jdbc:mysql://localhost:3306/my_db
      username: root
      password: root123
      # 连接池配置
      initial-size: 5
      min-idle: 5
      max-active: 20
      # 监控配置
      stat-view-servlet:
        enabled: true                    # 开启监控页面
        url-pattern: /druid/*            # 访问路径
        reset-enable: false              # 禁止重置统计数据
        login-username: admin            # 登录用户名
        login-password: admin123         # 登录密码
        allow: 127.0.0.1                 # 允许访问的 IP
      web-stat-filter:
        enabled: true                    # 开启 Web 监控
        url-pattern: /*                  # 拦截路径
        exclusions: "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*"
      # SQL 监控
      filter:
        stat:
          enabled: true                  # 开启 SQL 监控
          slow-sql-millis: 1000          # 慢 SQL 阈值（ms）
          log-slow-sql: true             # 打印慢 SQL 日志
        wall:
          enabled: true                  # 开启 SQL 防火墙
          config:
            multi-statement-allow: false # 禁止多语句

// Druid 监控配置类
@Configuration
public class DruidConfig {

    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.druid")
    public DataSource druidDataSource() {
        return new DruidDataSource();
    }

    // 配置 Druid 监控的 Servlet
    @Bean
    public ServletRegistrationBean<StatViewServlet> druidStatViewServlet() {
        ServletRegistrationBean<StatViewServlet> bean =
            new ServletRegistrationBean<>(new StatViewServlet(), "/druid/*");
        bean.addInitParameter("loginUsername", "admin");
        bean.addInitParameter("loginPassword", "admin123");
        bean.addInitParameter("allow", "127.0.0.1");
        return bean;
    }

    // 配置 Druid Web 监控的 Filter
    @Bean
    public FilterRegistrationBean<WebStatFilter> druidWebStatFilter() {
        FilterRegistrationBean<WebStatFilter> bean =
            new FilterRegistrationBean<>(new WebStatFilter());
        bean.addUrlPatterns("/*");
        bean.addInitParameter("exclusions", "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*");
        return bean;
    }
}

<!-- 引入 P6Spy 依赖 -->
<dependency>
    <groupId>p6spy</groupId>
    <artifactId>p6spy</artifactId>
    <version>3.9.1</version>
</dependency>

## application.yml 配置 P6Spy
spring:
  datasource:
    driver-class-name: com.p6spy.engine.spy.P6SpyDriver  # P6Spy 驱动
    url: jdbc:p6spy:mysql://localhost:3306/my_db?useSSL=false&serverTimezone=Asia/Shanghai
    # 注意 URL 前缀从 jdbc:mysql 改为 jdbc:p6spy:mysql

## spy.properties 配置文件
## 使用自定义日志格式
logMessageFormat=com.p6spy.engine.spy.appender.CustomLineFormat
customLogMessageFormat=执行耗时: %(executionTime)ms | SQL: %(sqlSingleLine)

## 日志输出方式
appender=com.p6spy.engine.spy.appender.StdoutLogger

## 排除的系统表
exclude=QRTZ_,ACT_

## 日期格式
dateformat=yyyy-MM-dd HH:mm:ss

## 只记录超过指定时间的 SQL（毫秒）
outagedetection=true
outagedetectioninterval=500

// 自定义 SQL 执行耗时拦截器
@Intercepts({
    @Signature(type = StatementHandler.class, method = "query", args = {
        Statement.class, ResultHandler.class
    }),
    @Signature(type = StatementHandler.class, method = "update", args = {
        Statement.class
    })
})
@Component
@Slf4j
public class SqlPerformanceInterceptor implements Interceptor {

    // 慢 SQL 阈值（毫秒）
    @Value("${mybatis.slow-sql-threshold:1000}")
    private long slowSqlThreshold;

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        long startTime = System.currentTimeMillis();
        
        try {
            // 执行原始方法
            return invocation.proceed();
        } finally {
            long costTime = System.currentTimeMillis() - startTime;
            
            if (costTime > slowSqlThreshold) {
                // 记录慢 SQL
                StatementHandler handler = (StatementHandler) invocation.getTarget();
                BoundSql boundSql = handler.getBoundSql();
                String sql = boundSql.getSql();
                
                log.warn("慢 SQL 耗时: {}ms | SQL: {}", costTime, sql);
                
                // 可以发送到监控系统
                MetricsCollector.recordSlowSql(sql, costTime);
            }
        }
    }
}

// 注册拦截器
@Configuration
public class MybatisPlusConfig {

    @Bean
    public SqlPerformanceInterceptor sqlPerformanceInterceptor() {
        return new SqlPerformanceInterceptor();
    }
}

// 数据迁移服务
@Service
@RequiredArgsConstructor
@Slf4j
public class DataMigrationService {

    private final JdbcTemplate sourceJdbcTemplate;
    private final JdbcTemplate targetJdbcTemplate;

    // 分批迁移数据
    public void migrateUsers(int batchSize) {
        long lastId = 0;
        int totalMigrated = 0;

        while (true) {
            // 从源库分批读取
            String querySql = "SELECT id, username, email, status, created_at " +
                              "FROM t_user WHERE id > ? ORDER BY id LIMIT ?";
            List<Map<String, Object>> batch = sourceJdbcTemplate.queryForList(
                querySql, lastId, batchSize);

            if (batch.isEmpty()) {
                break;  // 迁移完成
            }

            // 写入目标库
            String insertSql = "INSERT INTO t_user (id, username, email, status, created_at) " +
                               "VALUES (?, ?, ?, ?, ?)";
            targetJdbcTemplate.batchUpdate(insertSql, new BatchPreparedStatementSetter() {
                @Override
                public void setValues(PreparedStatement ps, int i) throws SQLException {
                    Map<String, Object> row = batch.get(i);
                    ps.setLong(1, ((Number) row.get("id")).longValue());
                    ps.setString(2, (String) row.get("username"));
                    ps.setString(3, (String) row.get("email"));
                    ps.setInt(4, ((Number) row.get("status")).intValue());
                    ps.setTimestamp(5, (Timestamp) row.get("created_at"));
                }

                @Override
                public int getBatchSize() {
                    return batch.size();
                }
            });

            // 更新游标
            lastId = ((Number) batch.get(batch.size() - 1).get("id")).longValue();
            totalMigrated += batch.size();
            log.info("已迁移 {} 条用户数据，当前游标 ID: {}", totalMigrated, lastId);
        }

        log.info("用户数据迁移完成，共迁移 {} 条", totalMigrated);
    }
}

@Service
@RequiredArgsConstructor
@Slf4j
public class BatchOperationService {

    private final UserMapper userMapper;
    private final SqlSessionFactory sqlSessionFactory;

    // × 逐条插入——性能极差
    public void insertOneByOne(List<User> users) {
        users.forEach(userMapper::insert);
        // 每次插入都提交一次事务，N 条数据 = N 次网络往返
    }

    // √ 方式1：MyBatis-Plus saveBatch
    @Transactional
    public void insertWithSaveBatch(List<User> users) {
        // IService.saveBatch() 内部使用 JDBC batch
        // 默认每 1000 条执行一次 batch
        userService.saveBatch(users, 500);
    }

    // √ 方式2：SqlSession 批量模式
    @Transactional
    public void insertWithSqlSessionBatch(List<User> users) {
        try (SqlSession sqlSession = sqlSessionFactory.openSession(ExecutorType.BATCH)) {
            UserMapper mapper = sqlSession.getMapper(UserMapper.class);
            for (int i = 0; i < users.size(); i++) {
                mapper.insert(users.get(i));
                // 每 500 条 flush 一次
                if (i > 0 && i % 500 == 0) {
                    sqlSession.flushStatements();
                    sqlSession.clearCache();
                }
            }
            sqlSession.flushStatements();  // 最后 flush 剩余的
        }
    }

    // √ 方式3：自定义批量插入 SQL
    @Transactional
    public void insertWithCustomBatchSql(List<User> users) {
        // 拼接多值 INSERT：INSERT INTO t_user (username, email) VALUES (?, ?), (?, ?), ...
        userMapper.batchInsert(users);
    }
}

// Mapper 接口
@Mapper
public interface UserMapper extends BaseMapper<User> {

    // 自定义批量插入
    @Insert({
        "<script>",
        "INSERT INTO t_user (username, email, status) VALUES ",
        "<foreach collection='list' item='item' separator=','>",
        "(#{item.username}, #{item.email}, #{item.status})",
        "</foreach>",
        "</script>"
    })
    int batchInsert(@Param("list") List<User> users);
}

// 1. MyBatis-Plus JSON 字段处理
@Data
@TableName(value = "t_product", autoResultMap = true)  // autoResultMap 必须开启
public class Product {
    @TableId
    private Long id;

    private String name;

    // JSON 字段——自动序列化/反序列化
    @TableField(typeHandler = JacksonTypeHandler.class)
    private ProductAttribute attributes;  // 自定义 Java 对象

    // JSON 数组字段
    @TableField(typeHandler = JacksonTypeHandler.class)
    private List<String> tags;
}

// JSON 字段对应的 Java 类
@Data
public class ProductAttribute {
    private String color;
    private String size;
    private Integer weight;
    private Map<String, Object> extra;  // 动态属性
}

// 2. JPA JSON 字段处理
@Entity
@Table(name = "t_product")
public class Product {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    // 使用 @Convert 注解自定义类型转换
    @Column(columnDefinition = "JSON")
    @Convert(converter = ProductAttributeConverter.class)
    private ProductAttribute attributes;
}

// 自定义 JPA AttributeConverter
@Converter(autoApply = false)
public class ProductAttributeConverter
        implements AttributeConverter<ProductAttribute, String> {

    private static final ObjectMapper objectMapper = new ObjectMapper();

    @Override
    public String convertToDatabaseColumn(ProductAttribute attribute) {
        // Java 对象 → JSON 字符串
        try {
            return attribute == null ? null : objectMapper.writeValueAsString(attribute);
        } catch (JsonProcessingException e) {
            throw new RuntimeException("JSON 序列化失败", e);
        }
    }

    @Override
    public ProductAttribute convertToEntityAttribute(String json) {
        // JSON 字符串 → Java 对象
        try {
            return StringUtils.isBlank(json) ? null :
                objectMapper.readValue(json, ProductAttribute.class);
        } catch (JsonProcessingException e) {
            throw new RuntimeException("JSON 反序列化失败", e);
        }
    }
}

// 3. JSON 字段查询
// MyBatis-Plus 中查询 JSON 字段
@Service
@RequiredArgsConstructor
public class ProductService {

    private final ProductMapper productMapper;

    // 使用原生 SQL 查询 JSON 字段
    @Select("SELECT * FROM t_product WHERE JSON_EXTRACT(attributes, '$.color') = #{color}")
    List<Product> findByColor(@Param("color") String color);

    // MySQL 5.7+ 简写语法
    @Select("SELECT * FROM t_product WHERE attributes->'$.color' = #{color}")
    List<Product> findByColorShort(@Param("color") String color);

    // 查询 JSON 数组是否包含某个值
    @Select("SELECT * FROM t_product WHERE JSON_CONTAINS(tags, '\"' || #{tag} || '\"')")
    List<Product> findByTag(@Param("tag") String tag);
}

@Service
public class DemoService {

@Transactional(rollbackFor = Exception.class)
    public void test1() {
        System.out.println("test1 run...");
        int i = 1 / 0;
        System.out.println("test1 finish...");
    }

}

@EnableTransactionManagement
@SpringBootApplication
public class DemoApplication {

public static void main(String[] args) {
        ConfigurableApplicationContext ctx = SpringApplication.run(DemoApplication.class, args);
        DemoService demoService = ctx.getBean(DemoService.class);
        demoService.test1();
    }

}

test1 run...
Exception in thread "main" java.lang.ArithmeticException: / by zero
	at com.example.demo.service.DemoService.test1(DemoService.java:12)
	at com.example.demo.service.DemoService?FastClassBySpringCGLIB?203c87bf.invoke(<generated>)

@Import(TransactionManagementConfigurationSelector.class)
public @interface EnableTransactionManagement {
	boolean proxyTargetClass() default false;

AdviceMode mode() default AdviceMode.PROXY;

	int order() default Ordered.LOWEST_PRECEDENCE;
}

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:
				return new String[] {TransactionManagementConfigUtils.TRANSACTION_ASPECT_CONFIGURATION_CLASS_NAME};
			default:
				return null;
		}
	}

}

public class AutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        boolean candidateFound = false;
        Set<String> annoTypes = importingClassMetadata.getAnnotationTypes();
        for (String annoType : annoTypes) {
            AnnotationAttributes candidate = AnnotationConfigUtils.attributesFor(importingClassMetadata, annoType);
            if (candidate == null) {
                continue;
            }
            Object mode = candidate.get("mode");
            Object proxyTargetClass = candidate.get("proxyTargetClass");
            if (mode != null && proxyTargetClass != null && AdviceMode.class == mode.getClass() &&
                    Boolean.class == proxyTargetClass.getClass()) {
                candidateFound = true;
                // PROXY模式下会额外注册Bean
                if (mode == AdviceMode.PROXY) {
                    AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry);
                    if ((Boolean) proxyTargetClass) {
                        AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
                        return;
                    }
                }
            }
        }
        if (!candidateFound) {
            String name = getClass().getSimpleName();
            // logger......
        }
    }

}

public static BeanDefinition registerAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry) {
    return registerAutoProxyCreatorIfNecessary(registry, null);
}

public static BeanDefinition registerAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry,
        @Nullable Object source) {
    return registerOrEscalateApcAsRequired(InfrastructureAdvisorAutoProxyCreator.class, registry, source);
}

@Nullable
private static BeanDefinition registerOrEscalateApcAsRequired(Class<?> cls, BeanDefinitionRegistry registry,
        @Nullable Object source) {

Assert.notNull(registry, "BeanDefinitionRegistry must not be null");

if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
        BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
        if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
            int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
            int requiredPriority = findPriorityForClass(cls);
            if (currentPriority < requiredPriority) {
                apcDefinition.setBeanClassName(cls.getName());
            }
        }
        return null;
    }

    RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
    beanDefinition.setSource(source);
    beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
    beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
    registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
    return beanDefinition;
}

public class InfrastructureAdvisorAutoProxyCreator extends AbstractAdvisorAutoProxyCreator
public abstract class AbstractAdvisorAutoProxyCreator extends AbstractAutoProxyCreator
public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
		implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware

@Configuration
public class ProxyTransactionManagementConfiguration extends AbstractTransactionManagementConfiguration {

@Bean(name = TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME)
	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
	public BeanFactoryTransactionAttributeSourceAdvisor transactionAdvisor() {
		BeanFactoryTransactionAttributeSourceAdvisor advisor = new BeanFactoryTransactionAttributeSourceAdvisor();
		advisor.setTransactionAttributeSource(transactionAttributeSource());
		advisor.setAdvice(transactionInterceptor());
		if (this.enableTx != null) {
			advisor.setOrder(this.enableTx.<Integer>getNumber("order"));
		}
		return advisor;
	}

@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;
	}

}

public class BeanFactoryTransactionAttributeSourceAdvisor extends AbstractBeanFactoryPointcutAdvisor {

@Nullable
	private TransactionAttributeSource transactionAttributeSource;

	private final TransactionAttributeSourcePointcut pointcut = new TransactionAttributeSourcePointcut() {
		@Override
		@Nullable
		protected TransactionAttributeSource getTransactionAttributeSource() {
			return transactionAttributeSource;
		}
	};

abstract class TransactionAttributeSourcePointcut extends StaticMethodMatcherPointcut implements Serializable {

	@Override
	public boolean matches(Method method, Class<?> targetClass) {
		if (TransactionalProxy.class.isAssignableFrom(targetClass) ||
				PlatformTransactionManager.class.isAssignableFrom(targetClass) ||
				PersistenceExceptionTranslator.class.isAssignableFrom(targetClass)) {
			return false;
		}
		TransactionAttributeSource tas = getTransactionAttributeSource();
		return (tas == null || tas.getTransactionAttribute(method, targetClass) != null);
	}

@Bean
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
public TransactionAttributeSource transactionAttributeSource() {
    return new AnnotationTransactionAttributeSource();
}

public AnnotationTransactionAttributeSource() {
    this(true);
}

public AnnotationTransactionAttributeSource(boolean publicMethodsOnly) {
    this.publicMethodsOnly = publicMethodsOnly;
    this.annotationParsers = new LinkedHashSet<>(2);
    this.annotationParsers.add(new SpringTransactionAnnotationParser());
    if (jta12Present) {
        this.annotationParsers.add(new JtaTransactionAnnotationParser());
    }
    if (ejb3Present) {
        this.annotationParsers.add(new Ejb3TransactionAnnotationParser());
    }
}

public class SpringTransactionAnnotationParser implements TransactionAnnotationParser, Serializable {

@Override
    @Nullable
    public TransactionAttribute parseTransactionAnnotation(AnnotatedElement ae) {
        // 搜索被标注的元素（类、方法）上是否最终标注了@Transactional注解
        AnnotationAttributes attributes = AnnotatedElementUtils.findMergedAnnotationAttributes(
                ae, Transactional.class, false, false);
        if (attributes != null) {
            return parseTransactionAnnotation(attributes);
        }
        else {
            return null;
        }
    }

public TransactionAttribute parseTransactionAnnotation(Transactional ann) {
        return parseTransactionAnnotation(AnnotationUtils.getAnnotationAttributes(ann, false, false));
    }

    protected TransactionAttribute parseTransactionAnnotation(AnnotationAttributes attributes) {
        RuleBasedTransactionAttribute rbta = new RuleBasedTransactionAttribute();
        // 解析事务传播行为
        Propagation propagation = attributes.getEnum("propagation");
        rbta.setPropagationBehavior(propagation.value());
        // 解析事务隔离级别
        Isolation isolation = attributes.getEnum("isolation");
        rbta.setIsolationLevel(isolation.value());
        // 解析超时
        rbta.setTimeout(attributes.getNumber("timeout").intValue());
        // 解析只读事务
        rbta.setReadOnly(attributes.getBoolean("readOnly"));
        rbta.setQualifier(attributes.getString("value"));
        ArrayList<RollbackRuleAttribute> rollBackRules = new ArrayList<>();
        // 解析回滚异常
        Class<?>[] rbf = attributes.getClassArray("rollbackFor");
        for (Class<?> rbRule : rbf) {
            RollbackRuleAttribute rule = new RollbackRuleAttribute(rbRule);
            rollBackRules.add(rule);
        }
        String[] rbfc = attributes.getStringArray("rollbackForClassName");
        for (String rbRule : rbfc) {
            RollbackRuleAttribute rule = new RollbackRuleAttribute(rbRule);
            rollBackRules.add(rule);
        }
        // 解析不回滚异常的“白名单”
        Class<?>[] nrbf = attributes.getClassArray("noRollbackFor");
        for (Class<?> rbRule : nrbf) {
            NoRollbackRuleAttribute rule = new NoRollbackRuleAttribute(rbRule);
            rollBackRules.add(rule);
        }
        String[] nrbfc = attributes.getStringArray("noRollbackForClassName");
        for (String rbRule : nrbfc) {
            NoRollbackRuleAttribute rule = new NoRollbackRuleAttribute(rbRule);
            rollBackRules.add(rule);
        }
        rbta.getRollbackRules().addAll(rollBackRules);
        return rbta;
    }
}

@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;
}

public class TransactionInterceptor extends TransactionAspectSupport implements MethodInterceptor, Serializable

@Configuration
public abstract class AbstractTransactionManagementConfiguration implements ImportAware {

@Nullable
    protected AnnotationAttributes enableTx;

@Nullable
    protected PlatformTransactionManager txManager;

@Override
    public void setImportMetadata(AnnotationMetadata importMetadata) {
        this.enableTx = AnnotationAttributes.fromMap(
                importMetadata.getAnnotationAttributes(EnableTransactionManagement.class.getName(), false));
        if (this.enableTx == null) {
            throw new IllegalArgumentException(
                    "@EnableTransactionManagement is not present on importing class " + importMetadata.getClassName());
        }
    }

@Autowired(required = false)
    void setConfigurers(Collection<TransactionManagementConfigurer> configurers) {
        if (CollectionUtils.isEmpty(configurers)) {
            return;
        }
        if (configurers.size() > 1) {
            throw new IllegalStateException("Only one TransactionManagementConfigurer may exist");
        }
        TransactionManagementConfigurer configurer = configurers.iterator().next();
        this.txManager = configurer.annotationDrivenTransactionManager();
    }

@Bean(name = TransactionManagementConfigUtils.TRANSACTIONAL_EVENT_LISTENER_FACTORY_BEAN_NAME)
    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    public static TransactionalEventListenerFactory transactionalEventListenerFactory() {
        return new TransactionalEventListenerFactory();
    }

}

@Service
public class DemoService {

@Autowired
    private USerDao userDao;

@Autowired
    private ApplicationEventPublisher applicationEventPublisher;

@Transactional(rollbackFor = Exception.class)
    public void test() {
        // 执行清空用户的数据库操作
        userDao.deleteAll();

// 使用事件广播器来广播 用户清除事件
        applicationEventPublisher.publishEvent(new UserCleanEvent());
    }
}

@Component
class MyTransactionListener {

@TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
    private void onTestEvent(UserCleanEvent event) {
        System.out.println("UserCleanEvent detected ......");
    }

}

// 定义 用户清除事件，它需要继承ApplicationEvent
class UserCleanEvent extends ApplicationEvent {

}

@Service
public class DemoService {

@Transactional(rollbackFor = Exception.class)
    public void test1() {
        System.out.println("test1 run...");
        int i = 1 / 0;
        System.out.println("test1 finish...");
    }

}

public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
    // ......
    try {
        // ......
        List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
        Object retVal;
        // ......
            retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();
        // ......
}

public Object proceed() throws Throwable {
    //  We start with an index of -1 and increment early.
    if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
        return invokeJoinpoint();
    }

    Object interceptorOrInterceptionAdvice =
            this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
    if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
        // ......
    }
    else {
        // It's an interceptor, so we just invoke it: The pointcut will have
        // been evaluated statically before this object was constructed.
        return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
    }
}

public Object invoke(MethodInvocation invocation) throws Throwable {
    // Work out the target class: may be null.
    // The TransactionAttributeSource should be passed the target class
    // as well as the method, which may be from an interface.
    Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);

    // Adapt to TransactionAspectSupport's invokeWithinTransaction...
    return invokeWithinTransaction(invocation.getMethod(), targetClass, invocation::proceed);
}

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

// If the transaction attribute is null, the method is non-transactional.
    TransactionAttributeSource tas = getTransactionAttributeSource();
    // 获取@Transactional的属性配置
    final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null);
    // 获取事务管理器（IOC容器中获取）
    final PlatformTransactionManager tm = determineTransactionManager(txAttr);
    final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);

if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) {
        // Standard transaction demarcation with getTransaction and commit/rollback calls.
        // 创建事务
        TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);

Object retVal;
        try {
            // This is an around advice: Invoke the next interceptor in the chain.
            // This will normally result in a target object being invoked.
            retVal = invocation.proceedWithInvocation();
        }
        catch (Throwable ex) {
            // target invocation exception
            // 回滚事务
            completeTransactionAfterThrowing(txInfo, ex);
            throw ex;
        }
        finally {
            cleanupTransactionInfo(txInfo);
        }
        // 提交事务
        commitTransactionAfterReturning(txInfo);
        return retVal;
    }

    else {
        // 与上面相似，省略。。。
    }
}

        try {
            retVal = invocation.proceedWithInvocation();
        }
        // ......
        // 提交事务
        commitTransactionAfterReturning(txInfo);
        return retVal;
    }

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

public final void commit(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");
    }

// 校验事务状态，如果在事务链中已经有操作将当前事务标记为 “需要回滚” ，则直接回滚事务
    DefaultTransactionStatus defStatus = (DefaultTransactionStatus) status;
    if (defStatus.isLocalRollbackOnly()) {
        if (defStatus.isDebug()) {
            logger.debug("Transactional code has requested rollback");
        }
        processRollback(defStatus, false);
        return;
    }

if (!shouldCommitOnGlobalRollbackOnly() && defStatus.isGlobalRollbackOnly()) {
        if (defStatus.isDebug()) {
            logger.debug("Global transaction is marked as rollback-only but transactional code requested commit");
        }
        processRollback(defStatus, true);
        return;
    }

    // 没有异常标记，提交事务
    processCommit(defStatus);
}

private void processCommit(DefaultTransactionStatus status) throws TransactionException {
    try {
        boolean beforeCompletionInvoked = false;

try {
            boolean unexpectedRollback = false;
            prepareForCommit(status);
            triggerBeforeCommit(status);
            triggerBeforeCompletion(status);
            beforeCompletionInvoked = true;

// 是否有保存点
            if (status.hasSavepoint()) {
                if (status.isDebug()) {
                    logger.debug("Releasing transaction savepoint");
                }
                unexpectedRollback = status.isGlobalRollbackOnly();
                // 保存点不会真正提交事务
                status.releaseHeldSavepoint();
            }
            // 全新的事务会执行commit操作（与事务传播行为有关）
            else if (status.isNewTransaction()) {
                if (status.isDebug()) {
                    logger.debug("Initiating transaction commit");
                }
                unexpectedRollback = status.isGlobalRollbackOnly();
                doCommit(status);
            }
            else if (isFailEarlyOnGlobalRollbackOnly()) {
                unexpectedRollback = status.isGlobalRollbackOnly();
            }

// Throw UnexpectedRollbackException if we have a global rollback-only
            // marker but still didn't get a corresponding exception from commit.
            if (unexpectedRollback) {
                throw new UnexpectedRollbackException(
                        "Transaction silently rolled back because it has been marked as rollback-only");
            }
        }
        // catch ......

    }
    finally {
        // 清除缓存资源
        cleanupAfterCompletion(status);
    }
}

protected void doCommit(DefaultTransactionStatus status) {
    DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();
    Connection con = txObject.getConnectionHolder().getConnection();
    if (status.isDebug()) {
        logger.debug("Committing JDBC transaction on Connection [" + con + "]");
    }
    try {
        con.commit();
    }
    catch (SQLException ex) {
        throw new TransactionSystemException("Could not commit JDBC transaction", ex);
    }
}

        try {
            retVal = invocation.proceedWithInvocation();
        }
        catch (Throwable ex) {
            completeTransactionAfterThrowing(txInfo, ex);
            throw ex;
        }

protected void completeTransactionAfterThrowing(@Nullable TransactionInfo txInfo, Throwable ex) {
    // 回滚必须要保证当前正在一个事务中
    if (txInfo != null && txInfo.getTransactionStatus() != null) {
        if (logger.isTraceEnabled()) {
            logger.trace("Completing transaction for [" + txInfo.getJoinpointIdentification() +
                    "] after exception: " + ex);
        }
        // 4.2.1.1 回滚的事务必须为RuntimeException或Error类型
        if (txInfo.transactionAttribute != null && txInfo.transactionAttribute.rollbackOn(ex)) {
            try {
                // 回滚事务
                txInfo.getTransactionManager().rollback(txInfo.getTransactionStatus());
            }
            // catch ......
        }
        else {
            // We don't roll back on this exception.
            // Will still roll back if TransactionStatus.isRollbackOnly() is true.
            // 不满足回滚条件，即便抛出异常也会提交事务
            try {
                txInfo.getTransactionManager().commit(txInfo.getTransactionStatus());
            }
            // catch ......
        }
    }
}

public boolean rollbackOn(Throwable ex) {
    return (ex instanceof RuntimeException || ex instanceof Error);
}

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");
    }

    DefaultTransactionStatus defStatus = (DefaultTransactionStatus) status;
    processRollback(defStatus, false);
}

private void processRollback(DefaultTransactionStatus status, boolean unexpected) {
    try {
        boolean unexpectedRollback = unexpected;

try {
            triggerBeforeCompletion(status);

            // 如果事务状态中发现了保存点，证明当前事务是NESTD类型（子事务），会回滚到保存点
            if (status.hasSavepoint()) {
                if (status.isDebug()) {
                    logger.debug("Rolling back transaction to savepoint");
                }
                status.rollbackToHeldSavepoint();
            }
            // 全新的事务才会完全回滚
            else if (status.isNewTransaction()) {
                if (status.isDebug()) {
                    logger.debug("Initiating transaction rollback");
                }
                doRollback(status);
            }
            // ......
    }
    finally {
        // 清除事务缓存
        cleanupAfterCompletion(status);
    }
}

protected void doRollback(DefaultTransactionStatus status) {
    DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();
    Connection con = txObject.getConnectionHolder().getConnection();
    if (status.isDebug()) {
        logger.debug("Rolling back JDBC transaction on Connection [" + con + "]");
    }
    try {
        con.rollback();
    }
    catch (SQLException ex) {
        throw new TransactionSystemException("Could not roll back JDBC transaction", ex);
    }
}

@Service
public class DemoService {

@Transactional(rollbackFor = Exception.class)
    public void test1() {
        System.out.println("test1 run...");
        int i = 1 / 0;
        System.out.println("test1 finish...");
    }

}

@Service
public class DemoService2 {

@Autowired
    private DemoService demoService;

@Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
    public void test2() {
        System.out.println("test2 run...");
        demoService.test1();
        System.out.println("test2 finish...");
    }

}

@EnableTransactionManagement
@SpringBootApplication
public class DemoApplication {

public static void main(String[] args) {
        ConfigurableApplicationContext ctx = SpringApplication.run(DemoApplication.class, args);
        DemoService2 demoService2 = ctx.getBean(DemoService2.class);
        demoService2.test2();
    }

}

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

// If the transaction attribute is null, the method is non-transactional.
    TransactionAttributeSource tas = getTransactionAttributeSource();
    final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null);
    final PlatformTransactionManager tm = determineTransactionManager(txAttr);
    final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);

if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) {
        // Standard transaction demarcation with getTransaction and commit/rollback calls.
        // 1.2 如果当前执行方法需要事务，则开启事务
        TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);

        Object retVal;
        try {
            // This is an around advice: Invoke the next interceptor in the chain.
            // This will normally result in a target object being invoked.
            retVal = invocation.proceedWithInvocation();
        }
        catch (Throwable ex) {
            // target invocation exception
            completeTransactionAfterThrowing(txInfo, ex);
            throw ex;
        }
        finally {
            cleanupTransactionInfo(txInfo);
        }
        commitTransactionAfterReturning(txInfo);
        return retVal;
    }
    // ......
}

protected TransactionInfo createTransactionIfNecessary(@Nullable PlatformTransactionManager tm,
        @Nullable TransactionAttribute txAttr, final String joinpointIdentification) {

// If no name specified, apply method identification as transaction name.
    // 如果未指定名称，则将方法名当做事务名称
    if (txAttr != null && txAttr.getName() == null) {
        txAttr = new DelegatingTransactionAttribute(txAttr) {
            @Override
            public String getName() {
                return joinpointIdentification;
            }
        };
    }

    TransactionStatus status = null;
    if (txAttr != null) {
        if (tm != null) {
            // 1.3 获取事务状态。
            status = tm.getTransaction(txAttr);
        }
        else {
            if (logger.isDebugEnabled()) {
                logger.debug("Skipping transactional joinpoint [" + joinpointIdentification +
                        "] because no transaction manager has been configured");
            }
        }
    }
    return prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
}

public final TransactionStatus getTransaction(@Nullable TransactionDefinition definition) throws TransactionException {
    // 获取/创建事务对象
    Object transaction = doGetTransaction();

// log ......

if (definition == null) {
        // Use defaults if no transaction definition given.
        definition = new DefaultTransactionDefinition();
    }

    // ......
}

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

// If the transaction attribute is null, the method is non-transactional.
    TransactionAttributeSource tas = getTransactionAttributeSource();
    // 事务定义信息已经在这里获取到了
    final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null);
    final PlatformTransactionManager tm = determineTransactionManager(txAttr);
    final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);

    if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) {
        // Standard transaction demarcation with getTransaction and commit/rollback calls.
        TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);

private final Map<Object, TransactionAttribute> attributeCache = new ConcurrentHashMap<>(1024);

public TransactionAttribute getTransactionAttribute(Method method, @Nullable Class<?> targetClass) {
    if (method.getDeclaringClass() == Object.class) {
        return null;
    }

    // First, see if we have a cached value.
    Object cacheKey = getCacheKey(method, targetClass);
    // 这里取出来的 cached 不是null
    TransactionAttribute cached = this.attributeCache.get(cacheKey);
    if (cached != null) {
        if (cached == NULL_TRANSACTION_ATTRIBUTE) {
            return null;
        }
        else {
            return cached;
        }
    }
    else {
        // We need to work it out.
        TransactionAttribute txAttr = computeTransactionAttribute(method, targetClass);
        // Put it in the cache.
        if (txAttr == null) {
            this.attributeCache.put(cacheKey, NULL_TRANSACTION_ATTRIBUTE);
        }
        else {
            String methodIdentification = ClassUtils.getQualifiedMethodName(method, targetClass);
            if (txAttr instanceof DefaultTransactionAttribute) {
                ((DefaultTransactionAttribute) txAttr).setDescriptor(methodIdentification);
            }
            if (logger.isTraceEnabled()) {
                logger.trace("Adding transactional method '" + methodIdentification + "' with attribute: " + txAttr);
            }
            this.attributeCache.put(cacheKey, txAttr);
        }
        return txAttr;
    }
}

public boolean matches(Method method, Class<?> targetClass) {
    if (TransactionalProxy.class.isAssignableFrom(targetClass) ||
            PlatformTransactionManager.class.isAssignableFrom(targetClass) ||
            PersistenceExceptionTranslator.class.isAssignableFrom(targetClass)) {
        return false;
    }
    TransactionAttributeSource tas = getTransactionAttributeSource();
    return (tas == null || tas.getTransactionAttribute(method, targetClass) != null);
}

public final TransactionStatus getTransaction(@Nullable TransactionDefinition definition) throws TransactionException {
    Object transaction = doGetTransaction();

// log ......

if (definition == null) {
        // Use defaults if no transaction definition given.
        definition = new DefaultTransactionDefinition();
    }

// 3.2 判断当前线程中是否存在事务
    if (isExistingTransaction(transaction)) {
        // Existing transaction found -> check propagation behavior to find out how to behave.
        return handleExistingTransaction(definition, transaction, debugEnabled);
    }

    // ......
}

protected boolean isExistingTransaction(Object transaction) {
    DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
    return (txObject.hasConnectionHolder() && txObject.getConnectionHolder().isTransactionActive());
}

public final TransactionStatus getTransaction(@Nullable TransactionDefinition definition) throws TransactionException {
    // ......
    // Check definition settings for new transaction.
    if (definition.getTimeout() < TransactionDefinition.TIMEOUT_DEFAULT) {
        throw new InvalidTimeoutException("Invalid transaction timeout", definition.getTimeout());
    }

    // No existing transaction found -> check propagation behavior to find out how to proceed.
    if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {
        throw new IllegalTransactionStateException(
                "No existing transaction found for transaction marked with propagation 'mandatory'");
    }
    else if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED ||
            definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW ||
            definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
        // ......
}

    SuspendedResourcesHolder suspendedResources = suspend(null);
    if (debugEnabled) {
        logger.debug("Creating new transaction with name [" + definition.getName() + "]: " + definition);
    }
    try {
        boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
        DefaultTransactionStatus status = newTransactionStatus(
                definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
        doBegin(transaction, definition);
        prepareSynchronization(status, definition);
        return status;
    }
    catch (RuntimeException | Error ex) {
        resume(null, suspendedResources);
        throw ex;
    }

protected final SuspendedResourcesHolder suspend(@Nullable Object transaction) throws TransactionException {
    if (TransactionSynchronizationManager.isSynchronizationActive()) {
        List<TransactionSynchronization> suspendedSynchronizations = doSuspendSynchronization();
        try {
            Object suspendedResources = null;
            if (transaction != null) {
                suspendedResources = doSuspend(transaction);
            }
            String name = TransactionSynchronizationManager.getCurrentTransactionName();
            TransactionSynchronizationManager.setCurrentTransactionName(null);
            boolean readOnly = TransactionSynchronizationManager.isCurrentTransactionReadOnly();
            TransactionSynchronizationManager.setCurrentTransactionReadOnly(false);
            Integer isolationLevel = TransactionSynchronizationManager.getCurrentTransactionIsolationLevel();
            TransactionSynchronizationManager.setCurrentTransactionIsolationLevel(null);
            boolean wasActive = TransactionSynchronizationManager.isActualTransactionActive();
            TransactionSynchronizationManager.setActualTransactionActive(false);
            return new SuspendedResourcesHolder(
                    suspendedResources, suspendedSynchronizations, name, readOnly, isolationLevel, wasActive);
        }
        catch (RuntimeException | Error ex) {
            // doSuspend failed - original transaction is still active...
            doResumeSynchronization(suspendedSynchronizations);
            throw ex;
        }
    }
    else if (transaction != null) {
        // Transaction active but no synchronization active.
        Object suspendedResources = doSuspend(transaction);
        return new SuspendedResourcesHolder(suspendedResources);
    }
    else {
        // Neither transaction nor synchronization active.
        return null;
    }
}

protected Object doSuspend(Object transaction) {
    DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
    txObject.setConnectionHolder(null);
    return TransactionSynchronizationManager.unbindResource(obtainDataSource());
}

protected DataSource obtainDataSource() {
    DataSource dataSource = getDataSource();
    Assert.state(dataSource != null, "No DataSource set");
    return dataSource;
}

public static Object unbindResource(Object key) throws IllegalStateException {
    Object actualKey = TransactionSynchronizationUtils.unwrapResourceIfNecessary(key);
    Object value = doUnbindResource(actualKey);
    if (value == null) {
        throw new IllegalStateException(
                "No value for key [" + actualKey + "] bound to thread [" + Thread.currentThread().getName() + "]");
    }
    return value;
}

private static final ThreadLocal<Map<Object, Object>> resources = new NamedThreadLocal<>("Transactional resources");

private static Object doUnbindResource(Object actualKey) {
    Map<Object, Object> map = resources.get();
    if (map == null) {
        return null;
    }
    Object value = map.remove(actualKey);
    // Remove entire ThreadLocal if empty...
    if (map.isEmpty()) {
        resources.remove();
    }
    // Transparently suppress a ResourceHolder that was marked as void...
    if (value instanceof ResourceHolder && ((ResourceHolder) value).isVoid()) {
        value = null;
    }
    if (value != null && logger.isTraceEnabled()) {
        logger.trace("Removed value [" + value + "] for key [" + actualKey + "] from thread [" +
                Thread.currentThread().getName() + "]");
    }
    return value;
}

DefaultTransactionStatus status = newTransactionStatus(
          definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);

protected DefaultTransactionStatus newTransactionStatus(
        TransactionDefinition definition, @Nullable Object transaction, boolean newTransaction,
        boolean newSynchronization, boolean debug, @Nullable Object suspendedResources) {

    boolean actualNewSynchronization = newSynchronization &&
            !TransactionSynchronizationManager.isSynchronizationActive();
    return new DefaultTransactionStatus(
            transaction, newTransaction, actualNewSynchronization,
            definition.isReadOnly(), debug, suspendedResources);
}

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

try {
        // 如果当前线程中没有ConnectionHolder，则会获取新的数据库连接，并放入ConnectionHolder（线程绑定）
        if (!txObject.hasConnectionHolder() ||
                txObject.getConnectionHolder().isSynchronizedWithTransaction()) {
            // 从DataSource中取connection
            Connection newCon = obtainDataSource().getConnection();
            if (logger.isDebugEnabled()) {
                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);

// Switch to manual commit if necessary. This is very expensive in some JDBC drivers,
        // so we don't want to do it unnecessarily (for example if we've explicitly
        // configured the connection pool to set it already).
        if (con.getAutoCommit()) {
            txObject.setMustRestoreAutoCommit(true);
            if (logger.isDebugEnabled()) {
                logger.debug("Switching JDBC Connection [" + con + "] to manual commit");
            }
            // 开启事务
            con.setAutoCommit(false);
        }

prepareTransactionalConnection(con, definition);
        // 标记事务状态为激活
        txObject.getConnectionHolder().setTransactionActive(true);

int timeout = determineTimeout(definition);
        if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) {
            txObject.getConnectionHolder().setTimeoutInSeconds(timeout);
        }

// Bind the connection holder to the thread.
        if (txObject.isNewConnectionHolder()) {
            TransactionSynchronizationManager.bindResource(obtainDataSource(), txObject.getConnectionHolder());
        }
    }

    catch (Throwable ex) {
        if (txObject.isNewConnectionHolder()) {
            DataSourceUtils.releaseConnection(con, obtainDataSource());
            txObject.setConnectionHolder(null, false);
        }
        throw new CannotCreateTransactionException("Could not open JDBC Connection for transaction", ex);
    }
}

protected void prepareSynchronization(DefaultTransactionStatus status, TransactionDefinition definition) {
    if (status.isNewSynchronization()) {
        TransactionSynchronizationManager.setActualTransactionActive(status.hasTransaction());
        TransactionSynchronizationManager.setCurrentTransactionIsolationLevel(
                definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT ?
                        definition.getIsolationLevel() : null);
        TransactionSynchronizationManager.setCurrentTransactionReadOnly(definition.isReadOnly());
        TransactionSynchronizationManager.setCurrentTransactionName(definition.getName());
        TransactionSynchronizationManager.initSynchronization();
    }
}

protected TransactionInfo createTransactionIfNecessary(@Nullable PlatformTransactionManager tm,
        @Nullable TransactionAttribute txAttr, final String joinpointIdentification) {
    // ......
    TransactionStatus status = null;
    if (txAttr != null) {
        if (tm != null) {
            status = tm.getTransaction(txAttr);
        }
        // ......
    }
    return prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
}

protected TransactionInfo prepareTransactionInfo(@Nullable PlatformTransactionManager tm,
        @Nullable TransactionAttribute txAttr, String joinpointIdentification,
        @Nullable TransactionStatus status) {

TransactionInfo txInfo = new TransactionInfo(tm, txAttr, joinpointIdentification);
    if (txAttr != null) {
        // We need a transaction for this method...
        if (logger.isTraceEnabled()) {
            logger.trace("Getting transaction for [" + txInfo.getJoinpointIdentification() + "]");
        }
        // The transaction manager will flag an error if an incompatible tx already exists.
        txInfo.newTransactionStatus(status);
    }
    else {
        // The TransactionInfo.hasTransaction() method will return false. We created it only
        // to preserve the integrity of the ThreadLocal stack maintained in this class.
        if (logger.isTraceEnabled()) {
            logger.trace("No need to create transaction for [" + joinpointIdentification +
                    "]: This method is not transactional.");
        }
    }

    // We always bind the TransactionInfo to the thread, even if we didn't create
    // a new transaction here. This guarantees that the TransactionInfo stack
    // will be managed correctly even if no transaction was created by this aspect.
    txInfo.bindToThread();
    return txInfo;
}

private static final ThreadLocal<TransactionInfo> transactionInfoHolder =
        new NamedThreadLocal<>("Current aspect-driven transaction");

private void bindToThread() {
    // Expose current TransactionStatus, preserving any existing TransactionStatus
    // for restoration after this transaction is complete.
    this.oldTransactionInfo = transactionInfoHolder.get();
    transactionInfoHolder.set(this);
}

@Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
public void test2() {
    System.out.println("test2 run...");
    demoService.test1();
    System.out.println("test2 finish...");
}

protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass,
        final InvocationCallback invocation) throws Throwable {
    // ......

if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) {
        // Standard transaction demarcation with getTransaction and commit/rollback calls.
        TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);

        // ......
    }
    // ......
}

protected TransactionInfo createTransactionIfNecessary(@Nullable PlatformTransactionManager tm,
        @Nullable TransactionAttribute txAttr, final String joinpointIdentification) {
    // .....
    TransactionStatus status = null;
    if (txAttr != null) {
        if (tm != null) {
            status = tm.getTransaction(txAttr);
        }
        // ......
    }
    return prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
}

public final TransactionStatus getTransaction(@Nullable TransactionDefinition definition) throws TransactionException {
    Object transaction = doGetTransaction();

// ......

    if (isExistingTransaction(transaction)) {
        // Existing transaction found -> check propagation behavior to find out how to behave.
        return handleExistingTransaction(definition, transaction, debugEnabled);
    }

protected Object doGetTransaction() {
    DataSourceTransactionObject txObject = new DataSourceTransactionObject();
    txObject.setSavepointAllowed(isNestedTransactionAllowed());
    // 由于之前已经在ThreadLocal中放入DemoService2的事务，此时可以去除
    ConnectionHolder conHolder =
            (ConnectionHolder) TransactionSynchronizationManager.getResource(obtainDataSource());
    txObject.setConnectionHolder(conHolder, false);
    return txObject;
}

private TransactionStatus handleExistingTransaction(
        TransactionDefinition definition, Object transaction, boolean debugEnabled)
        throws TransactionException {

// 如果当前方法的事务行为是NEVER（不允许），则抛出异常
    if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NEVER) {
        throw new IllegalTransactionStateException(
                "Existing transaction found for transaction marked with propagation 'never'");
    }

// 如果当前方法的事务行为是NOT_SUPPORTED，挂起当前事务，执行完成之后，再次唤醒
    if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NOT_SUPPORTED) {
        if (debugEnabled) {
            logger.debug("Suspending current transaction");
        }
        Object suspendedResources = suspend(transaction);
        boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
        return prepareTransactionStatus(
                definition, null, false, newSynchronization, debugEnabled, suspendedResources);
    }

// 如果当前方法的事务行为是REQUIRED_NEW,挂起当前事务，并新建一个事务执行，执行完之后，唤醒上个事务
    if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW) {
        if (debugEnabled) {
            logger.debug("Suspending current transaction, creating new transaction with name [" +
                    definition.getName() + "]");
        }
        SuspendedResourcesHolder suspendedResources = suspend(transaction);
        try {
            boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
            DefaultTransactionStatus status = newTransactionStatus(
                    definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
            doBegin(transaction, definition);
            prepareSynchronization(status, definition);
            return status;
        }
        catch (RuntimeException | Error beginEx) {
            resumeAfterBeginException(transaction, suspendedResources, beginEx);
            throw beginEx;
        }
    }

// 如果当前方法的事务行为是NESTED，创建一个保存点
    if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
        if (!isNestedTransactionAllowed()) {
            throw new NestedTransactionNotSupportedException(
                    "Transaction manager does not allow nested transactions by default - " +
                    "specify 'nestedTransactionAllowed' property with value 'true'");
        }
        if (debugEnabled) {
            logger.debug("Creating nested transaction with name [" + definition.getName() + "]");
        }
        if (useSavepointForNestedTransaction()) {
            // Create savepoint within existing Spring-managed transaction,
            // through the SavepointManager API implemented by TransactionStatus.
            // Usually uses JDBC 3.0 savepoints. Never activates Spring synchronization.
            DefaultTransactionStatus status =
                    prepareTransactionStatus(definition, transaction, false, false, debugEnabled, null);
            status.createAndHoldSavepoint();
            return status;
        }
        else {
            // Nested transaction through nested begin and commit/rollback calls.
            // Usually only for JTA: Spring synchronization might get activated here
            // in case of a pre-existing JTA transaction.
            boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
            DefaultTransactionStatus status = newTransactionStatus(
                    definition, transaction, true, newSynchronization, debugEnabled, null);
            doBegin(transaction, definition);
            prepareSynchronization(status, definition);
            return status;
        }
    }

    // Assumably PROPAGATION_SUPPORTS or PROPAGATION_REQUIRED.
    if (debugEnabled) {
        logger.debug("Participating in existing transaction");
    }
    if (isValidateExistingTransaction()) {
        if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT) {
            Integer currentIsolationLevel = TransactionSynchronizationManager.getCurrentTransactionIsolationLevel();
            if (currentIsolationLevel == null || currentIsolationLevel != definition.getIsolationLevel()) {
                Constants isoConstants = DefaultTransactionDefinition.constants;
                throw new IllegalTransactionStateException("Participating transaction with definition [" +
                        definition + "] specifies isolation level which is incompatible with existing transaction: " +
                        (currentIsolationLevel != null ?
                                isoConstants.toCode(currentIsolationLevel, DefaultTransactionDefinition.PREFIX_ISOLATION) :
                                "(unknown)"));
            }
        }
        if (!definition.isReadOnly()) {
            if (TransactionSynchronizationManager.isCurrentTransactionReadOnly()) {
                throw new IllegalTransactionStateException("Participating transaction with definition [" +
                        definition + "] is not marked as read-only but existing transaction is");
            }
        }
    }
    boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
    return prepareTransactionStatus(definition, transaction, false, newSynchronization, debugEnabled, null);
}

private TransactionStatus handleExistingTransaction(
        TransactionDefinition definition, Object transaction, boolean debugEnabled)
        throws TransactionException {
    // ......
    // 如果当前方法的事务行为是REQUIRED_NEW,挂起当前事务，并新建一个事务执行，执行完之后，唤醒上个事务
    if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW) {
        if (debugEnabled) {
            logger.debug("Suspending current transaction, creating new transaction with name [" +
                    definition.getName() + "]");
        }
        SuspendedResourcesHolder suspendedResources = suspend(transaction);
        try {
            boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
            DefaultTransactionStatus status = newTransactionStatus(
                    definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
            doBegin(transaction, definition);
            prepareSynchronization(status, definition);
            return status;
        }
        catch (RuntimeException | Error beginEx) {
            resumeAfterBeginException(transaction, suspendedResources, beginEx);
            throw beginEx;
        }
    }

    // ......
    return prepareTransactionStatus(definition, transaction, false, newSynchronization, debugEnabled, null);
}

private void cleanupAfterCompletion(DefaultTransactionStatus status) {
    status.setCompleted();
    if (status.isNewSynchronization()) {
        TransactionSynchronizationManager.clear();
    }
    if (status.isNewTransaction()) {
        doCleanupAfterCompletion(status.getTransaction());
    }
    if (status.getSuspendedResources() != null) {
        if (status.isDebug()) {
            logger.debug("Resuming suspended transaction after completion of inner transaction");
        }
        Object transaction = (status.hasTransaction() ? status.getTransaction() : null);
        resume(transaction, (SuspendedResourcesHolder) status.getSuspendedResources());
    }
}

protected final void resume(@Nullable Object transaction, @Nullable SuspendedResourcesHolder resourcesHolder)
        throws TransactionException {

    if (resourcesHolder != null) {
        Object suspendedResources = resourcesHolder.suspendedResources;
        if (suspendedResources != null) {
            doResume(transaction, suspendedResources);
        }
        List<TransactionSynchronization> suspendedSynchronizations = resourcesHolder.suspendedSynchronizations;
        if (suspendedSynchronizations != null) {
            TransactionSynchronizationManager.setActualTransactionActive(resourcesHolder.wasActive);
            TransactionSynchronizationManager.setCurrentTransactionIsolationLevel(resourcesHolder.isolationLevel);
            TransactionSynchronizationManager.setCurrentTransactionReadOnly(resourcesHolder.readOnly);
            TransactionSynchronizationManager.setCurrentTransactionName(resourcesHolder.name);
            doResumeSynchronization(suspendedSynchronizations);
        }
    }
}

protected void doResume(@Nullable Object transaction, Object suspendedResources) {
    TransactionSynchronizationManager.bindResource(obtainDataSource(), suspendedResources);
}

private TransactionStatus handleExistingTransaction(
        TransactionDefinition definition, Object transaction, boolean debugEnabled)
        throws TransactionException {
    // ......
    // 如果当前方法的事务行为是NESTED，创建一个保存点
    if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
        if (!isNestedTransactionAllowed()) {
            throw new NestedTransactionNotSupportedException(
                    "Transaction manager does not allow nested transactions by default - " +
                    "specify 'nestedTransactionAllowed' property with value 'true'");
        }
        if (debugEnabled) {
            logger.debug("Creating nested transaction with name [" + definition.getName() + "]");
        }
        if (useSavepointForNestedTransaction()) {
            // Create savepoint within existing Spring-managed transaction,
            // through the SavepointManager API implemented by TransactionStatus.
            // Usually uses JDBC 3.0 savepoints. Never activates Spring synchronization.
            DefaultTransactionStatus status =
                    prepareTransactionStatus(definition, transaction, false, false, debugEnabled, null);
            status.createAndHoldSavepoint();
            return status;
        }
        else {
            // Nested transaction through nested begin and commit/rollback calls.
            // Usually only for JTA: Spring synchronization might get activated here
            // in case of a pre-existing JTA transaction.
            boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
            DefaultTransactionStatus status = newTransactionStatus(
                    definition, transaction, true, newSynchronization, debugEnabled, null);
            doBegin(transaction, definition);
            prepareSynchronization(status, definition);
            return status;
        }
    }

    // ......
    return prepareTransactionStatus(definition, transaction, false, newSynchronization, debugEnabled, null);
}

protected boolean useSavepointForNestedTransaction() {
    return true;
}

protected final DefaultTransactionStatus prepareTransactionStatus(
        TransactionDefinition definition, @Nullable Object transaction, boolean newTransaction,
        boolean newSynchronization, boolean debug, @Nullable Object suspendedResources) {

    DefaultTransactionStatus status = newTransactionStatus(
            definition, transaction, newTransaction, newSynchronization, debug, suspendedResources);
    prepareSynchronization(status, definition);
    return status;
}

public void createAndHoldSavepoint() throws TransactionException {
    setSavepoint(getSavepointManager().createSavepoint());
}

protected SavepointManager getSavepointManager() {
    Object transaction = this.transaction;
    if (!(transaction instanceof SavepointManager)) {
        throw new NestedTransactionNotSupportedException(
                "Transaction object [" + this.transaction + "] does not support savepoints");
    }
    return (SavepointManager) transaction;
}

public Object createSavepoint() throws TransactionException {
    ConnectionHolder conHolder = getConnectionHolderForSavepoint();
    try {
        if (!conHolder.supportsSavepoints()) {
            throw new NestedTransactionNotSupportedException(
                    "Cannot create a nested transaction because savepoints are not supported by your JDBC driver");
        }
        if (conHolder.isRollbackOnly()) {
            throw new CannotCreateTransactionException(
                    "Cannot create savepoint for transaction which is already marked as rollback-only");
        }
        return conHolder.createSavepoint();
    }
    catch (SQLException ex) {
        throw new CannotCreateTransactionException("Could not create JDBC savepoint", ex);
    }
}

public Savepoint createSavepoint() throws SQLException {
    this.savepointCounter++;
    return getConnection().setSavepoint(SAVEPOINT_NAME_PREFIX + this.savepointCounter);
}