<!-- MyBatis核心依賴 -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.13</version>
</dependency>
<!-- MySQL驅(qū)動 -->
<dependency>
    <groupId>com.mysql</groupId>
    <artifactId>mysql-connector-j</artifactId>
    <version>8.0.33</version>
</dependency>
<!-- 數(shù)據(jù)源（C3P0） -->
<dependency>
    <groupId>com.mchange</groupId>
    <artifactId>c3p0</artifactId>
    <version>0.9.5.5</version>
</dependency>

<configuration>
    <!-- 環(huán)境配置：配置事務(wù)工廠和數(shù)據(jù)源 -->
    <environments default="development">
        <environment id="development">
            <!-- 事務(wù)工廠：使用JDBC事務(wù)工廠 -->
            <transactionManager type="JDBC"/>
            <!-- 數(shù)據(jù)源：C3P0連接池 -->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/test_mybatis?useSSL=false&serverTimezone=Asia/Shanghai"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
                <property name="poolMaximumActiveConnections" value="10"/>
            </dataSource>
        </environment>
    </environments>
    <!-- 映射器掃描 -->
    <mappers>
        <mapper resource="mapper/OrderMapper.xml"/>
        <mapper resource="mapper/ProductMapper.xml"/>
    </mappers>
</configuration>

public interface OrderMapper {
    int insertOrder(Order order);
}

public interface ProductMapper {
    int decreaseStock(@Param("productId") Long productId, @Param("num") Integer num);
}

<mapper namespace="com.example.mapper.OrderMapper">
    <insert id="insertOrder" parameterType="com.example.entity.Order">
        INSERT INTO `order`(order_no, product_id, num, create_time)
        VALUES(#{orderNo}, #{productId}, #{num}, NOW())
    </insert>
</mapper>

<mapper namespace="com.example.mapper.ProductMapper">
    <update id="decreaseStock">
        UPDATE product SET stock = stock - #{num} WHERE id = #{productId} AND stock >= #{num}
    </update>
</mapper>

public class TransactionDemo {
    public static void main(String[] args) {
        // 1. 加載MyBatis配置，創(chuàng)建SqlSessionFactory
        String resource = "mybatis-config.xml";
        try (InputStream inputStream = Resources.getResourceAsStream(resource)) {
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
            // 2. 開啟SqlSession，關(guān)閉自動提交（false表示手動控制事務(wù)）
            SqlSession sqlSession = sqlSessionFactory.openSession(false);
            try {
                // 3. 獲取Mapper接口
                OrderMapper orderMapper = sqlSession.getMapper(OrderMapper.class);
                ProductMapper productMapper = sqlSession.getMapper(ProductMapper.class);
                // 4. 模擬下單流程：① 插入訂單；② 扣減庫存
                Order order = new Order();
                order.setOrderNo(UUID.randomUUID().toString());
                order.setProductId(1L);
                order.setNum(2);
                orderMapper.insertOrder(order); // 第一步：插入訂單
                int rows = productMapper.decreaseStock(1L, 2); // 第二步：扣減庫存
                if (rows == 0) {
                    throw new RuntimeException("庫存不足，扣減失敗");
                }
                // 5. 所有操作成功，提交事務(wù)
                sqlSession.commit();
                System.out.println("事務(wù)提交成功：下單流程完成");
            } catch (Exception e) {
                // 6. 發(fā)生異常，回滾事務(wù)
                sqlSession.rollback();
                System.out.println("事務(wù)回滾：" + e.getMessage());
            } finally {
                // 7. 關(guān)閉SqlSession，釋放連接
                sqlSession.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.7.10</version>
</parent>
<dependencies>
    <!-- Spring Web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- MyBatis + Spring Boot整合依賴 -->
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>2.3.1</version>
    </dependency>
    <!-- MySQL驅(qū)動 -->
    <dependency>
        <groupId>com.mysql</groupId>
        <artifactId>mysql-connector-j</artifactId>
        <scope>runtime</scope>
    </dependency>
    <!-- Lombok -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/test_mybatis?useSSL=false&serverTimezone=Asia/Shanghai
    username: root
    password: 123456
  # Spring事務(wù)配置（可選，默認已配置DataSourceTransactionManager）
  transaction:
    rollback-on-commit-failure: true # 提交失敗時回滾
mybatis:
  mapper-locations: classpath:mapper/**/*.xml
  type-aliases-package: com.example.entity
  configuration:
    map-underscore-to-camel-case: true
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl # 打印SQL，便于調(diào)試

@Service
public class OrderService {
    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private ProductMapper productMapper;
    /**
     * 下單流程：插入訂單 + 扣減庫存
     * @Transactional：聲明式事務(wù)，默認 RuntimeException 觸發(fā)回滾
     */
    @Transactional(
            rollbackFor = Exception.class, // 所有異常都回滾（默認僅RuntimeException回滾）
            propagation = Propagation.REQUIRED, // 事務(wù)傳播行為：默認，當(dāng)前無事務(wù)則創(chuàng)建新事務(wù)
            isolation = Isolation.DEFAULT // 隔離級別：默認，使用數(shù)據(jù)庫默認隔離級別
    )
    public void createOrder(Order order) {
        // 1. 插入訂單
        orderMapper.insertOrder(order);
        // 2. 扣減庫存
        int rows = productMapper.decreaseStock(order.getProductId(), order.getNum());
        if (rows == 0) {
            throw new RuntimeException("庫存不足，下單失敗");
        }
        // 3. 模擬其他業(yè)務(wù)操作（如記錄日志）
        System.out.println("下單成功，訂單號：" + order.getOrderNo());
    }
}

@RestController
@RequestMapping("/api/orders")
public class OrderController {
    @Autowired
    private OrderService orderService;
    @PostMapping
    public ResponseEntity<String> createOrder(@RequestBody Order order) {
        try {
            order.setOrderNo(UUID.randomUUID().toString());
            orderService.createOrder(order);
            return ResponseEntity.ok("下單成功");
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("下單失?。? + e.getMessage());
        }
    }
}

// 純查詢方法，設(shè)置readOnly=true優(yōu)化性能
@Transactional(readOnly = true, propagation = Propagation.SUPPORTS)
public List<Order> getOrderByUserId(Long userId) {
    return orderMapper.selectByUserId(userId);
}

// 轉(zhuǎn)賬業(yè)務(wù)：扣減付款方余額 + 增加收款方余額，要求強一致性
@Transactional(
        rollbackFor = Exception.class,
        isolation = Isolation.READ_COMMITTED,
        timeout = 30
)
public void transfer(Long fromUserId, Long toUserId, BigDecimal amount) {
    // 扣減付款方余額
    userAccountMapper.decreaseBalance(fromUserId, amount);
    // 增加收款方余額
    userAccountMapper.increaseBalance(toUserId, amount);
}

// 主事務(wù)：創(chuàng)建訂單
@Transactional(rollbackFor = Exception.class)
public void createOrder(Order order) {
    orderMapper.insertOrder(order);
    // 調(diào)用子事務(wù)方法（創(chuàng)建訂單日志，獨立事務(wù)，即使失敗不影響主事務(wù)）
    logService.recordOrderLog(order.getId());
}
// 子事務(wù)：記錄訂單日志（獨立事務(wù)）
@Transactional(propagation = Propagation.REQUIRES_NEW, rollbackFor = Exception.class)
public void recordOrderLog(Long orderId) {
    OrderLog log = new OrderLog();
    log.setOrderId(orderId);
    log.setOperateTime(LocalDateTime.now());
    orderLogMapper.insert(log);
}