事务管理：@Transactional 的代理本质与七个失效现场

spring:
  datasource:
    url: jdbc:h2:mem:tx
    username: sa
    password: ""
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true

@Entity
public class Product {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private Integer stock;
    protected Product() { }
    // getter/setter 略
}

@Entity
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String sku;
    private Integer quantity;
    protected Order() { }
    // getter/setter 略
}

public interface ProductRepository extends JpaRepository<Product, Long> {

    @Modifying
    @Query("update Product p set p.stock = p.stock - :n where p.id = :id and p.stock >= :n")
    int deductStock(Long id, int n);
}

public interface OrderRepository extends JpaRepository<Order, Long> {
}

@Service
public class OrderService {
    private final ProductRepository productRepository;
    private final OrderRepository orderRepository;

    public OrderService(ProductRepository productRepository, OrderRepository orderRepository) {
        this.productRepository = productRepository;
        this.orderRepository = orderRepository;
    }
    @Transactional
    public Long placeOrder(Long productId, int quantity) {
        int updated = productRepository.deductStock(productId, quantity);
        if (updated == 0) {
            throw new IllegalStateException("库存不足");
        }
        Order order = new Order();
        order.setSku("P-" + productId);
        order.setQuantity(quantity);
        return orderRepository.save(order).getId();
    }
}

@Bean
CommandLineRunner demo(OrderService orderService, ProductRepository products, OrderRepository orders) {
    return args -> {
        Product p = new Product();
        p.setName("机械键盘");
        p.setStock(10);
        products.save(p);
        orderService.placeOrder(p.getId(), 2);            // 正常下单
        try {
            orderService.placeOrder(p.getId(), 99);       // 库存不足，抛异常
        } catch (Exception e) {
            System.out.println("捕获：" + e.getMessage());
        }
        System.out.println("剩余库存：" + products.findById(p.getId()).orElseThrow().getStock());
        System.out.println("订单条数：" + orders.count());
    };
}

捕获：库存不足
剩余库存：8
订单条数：1

调用方 ──调用 placeOrder──> 代理对象
   │ 1 begin：从连接池借连接，autoCommit = false
   ▼
目标对象（你的业务代码，全程用这条连接发 SQL）
   ├─ 正常返回 → 2 commit：connection.commit()
   └─ 抛出异常 → 2 rollback：connection.rollback()，随后归还连接

@Transactional
public void placeOrder(Long productId, int quantity) {
    auditService.record("下单", productId);          // REQUIRES_NEW：独立提交，不随下单回滚
    productRepository.deductStock(productId, quantity);
    throw new IllegalStateException("下游故障");      // 外层回滚
}

@Transactional
public void outer() {
    this.inner();                     // this 是目标对象，不是代理——传播逻辑长在代理身上
}

@Transactional(propagation = Propagation.REQUIRES_NEW)
public void inner() { }

@Transactional
public void checkedBombs() throws Exception {
    orderRepository.save(new Order());
    throw new Exception("受检异常");            // 直觉说该回滚，实际提交了
}

// 任意入口调用并接住异常，随后查库：
try {
    s.checkedBombs();
} catch (Exception e) {
    System.out.println("捕获：" + e.getMessage());
}
System.out.println(orders.count());            // 1：订单留下了

@Transactional
public void swallowed() {
    try {
        orderRepository.save(new Order());
        throw new IllegalStateException("炸了");
    } catch (Exception e) {
        System.out.println("只记日志，不往外抛");
    }
}
// 代理只看「方法有没有往外抛异常」——看到的是正常返回，于是提交

@Transactional
public void asyncSave() {
    new Thread(() -> orderRepository.save(new Order())).start();   // 另一条连接，自动提交
    throw new IllegalStateException("主线程回滚");                  // 主线程立即回滚
}
// 结果：订单留下了——它从头到尾就没进过这个事务

public class ReportExporter {              // 没有 @Service，也没被注入
    @Transactional
    public void export() { /* ... */ }
}
// 某处：new ReportExporter().export();     注解只是注释，没有 Bean 就没有代理

@Service
public class ImportService {

    private final TransactionTemplate tx;             // Boot 自动配置了该 Bean
    private final ProductRepository products;

    public ImportService(TransactionTemplate tx, ProductRepository products) {
        this.tx = tx;
        this.products = products;
    }

    public int importProducts(List<Product> all) {
        int committed = 0;
        for (int i = 0; i < all.size(); i += 200) {
            List<Product> batch = all.subList(i, Math.min(i + 200, all.size()));
            tx.executeWithoutResult(status -> products.saveAll(batch));   // 每批一个独立事务
            committed += batch.size();
        }
        return committed;
    }
}