@Transactional 的超时与只读属性

@Transactional(readOnly = true, timeout = 10)
public List<Student> findAllStudents() { ... }

@Transactional(timeout = 5)
public void quickUpdate(String id, String status) { ... }

package com.feixiang.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;

@Service
public class ReportService {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    // 大数据量报表查询：只读 + 30 秒超时
    @Transactional(readOnly = true, timeout = 30)
    public List<Map<String, Object>> exportUserReport(String status) {
        System.out.println("[报表导出] 开始查询，状态过滤：" + status);

        // 模拟复杂查询（实际可能是多表 JOIN、聚合）
        List<Map<String, Object>> result = jdbcTemplate.queryForList(
            "SELECT user_id, username, register_date, status " +
            "FROM app_user WHERE status = ? ORDER BY register_date DESC",
            status
        );

        System.out.println("[报表导出] 查询完成，记录数：" + result.size());
        return result;
    }

    // 快速统计：只读 + 5 秒超时
    @Transactional(readOnly = true, timeout = 5)
    public int countActiveUsers() {
        return jdbcTemplate.queryForObject(
            "SELECT COUNT(*) FROM app_user WHERE status = 'ACTIVE'",
            Integer.class
        );
    }
}

package com.feixiang.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class FinanceService {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    // 限时扣款：5 秒超时，防止死锁拖垮连接池
    @Transactional(timeout = 5)
    public void deductSalary(int empId, double amount) {
        System.out.println("[财务扣款] 开始处理，员工：" + empId + "，金额：" + amount);

        // 1. 查询员工当前工资余额
        Double currentBalance = jdbcTemplate.queryForObject(
            "SELECT balance FROM employee_account WHERE emp_id = ?",
            Double.class, empId
        );
        System.out.println("[财务扣款] 当前余额：" + currentBalance);

        if (currentBalance < amount) {
            throw new IllegalStateException("余额不足，员工：" + empId);
        }

        // 2. 模拟复杂审批逻辑（可能耗时）
        simulateApprovalProcess();

        // 3. 执行扣款
        jdbcTemplate.update(
            "UPDATE employee_account SET balance = balance - ? WHERE emp_id = ?",
            amount, empId
        );

        // 4. 插入财务记录
        jdbcTemplate.update(
            "INSERT INTO finance_record (emp_id, amount, record_type) VALUES (?, ?, 'DEDUCT')",
            empId, amount
        );

        System.out.println("[财务扣款] 处理完成，员工：" + empId);
    }

    // 模拟可能超时的审批流程
    private void simulateApprovalProcess() {
        try {
            // 模拟调用外部审批系统，可能耗时 3-10 秒
            Thread.sleep(6000); // 故意设置 6 秒，超过 5 秒超时限制
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

package com.feixiang;

import com.feixiang.service.FinanceService;
import com.feixiang.service.ReportService;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class TimeoutReadOnlyTest {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext ctx =
            new AnnotationConfigApplicationContext("com.feixiang");
        ReportService reportService = ctx.getBean(ReportService.class);
        FinanceService financeService = ctx.getBean(FinanceService.class);

        // 场景一：正常报表查询（只读 + 30 秒超时）
        try {
            List<Map<String, Object>> report = reportService.exportUserReport("ACTIVE");
            System.out.println("[场景一] 报表导出成功，记录数：" + report.size());
        } catch (Exception e) {
            System.err.println("[场景一] 报表导出失败：" + e.getClass().getSimpleName() + " - " + e.getMessage());
        }

        // 场景二：快速统计（只读 + 5 秒超时）
        try {
            int count = reportService.countActiveUsers();
            System.out.println("[场景二] 活跃用户统计：" + count);
        } catch (Exception e) {
            System.err.println("[场景二] 统计失败：" + e.getClass().getSimpleName() + " - " + e.getMessage());
        }

        // 场景三：限时扣款超时（5 秒超时）
        try {
            financeService.deductSalary(1001, 2000.00);
            System.out.println("[场景三] 扣款成功");
        } catch (Exception e) {
            System.err.println("[场景三] 扣款失败：" + e.getClass().getSimpleName() + " - " + e.getMessage());
        }

        ctx.close();
    }
}

@Service
public class MisunderstoodService {

    @Transactional(timeout = 5)
    public void longRunningBusiness() {
        // 1. 执行一个 1 秒的 SQL
        jdbcTemplate.update("...");

        // 2. 调用外部 HTTP 接口，耗时 10 秒
        callExternalApi();  // 不涉及数据库交互

        // 3. 再执行一个 1 秒的 SQL
        jdbcTemplate.update("...");  // 此时才检测到超时！
    }
}

@Service
public class RiskyService {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    // 错误：readOnly = true 中执行 INSERT
    @Transactional(readOnly = true)
    public void queryAndInsert(String name) {
        // 查询操作
        int count = jdbcTemplate.queryForObject(
            "SELECT COUNT(*) FROM app_user", Integer.class
        );

        // 危险：在只读事务中执行写操作
        jdbcTemplate.update(
            "INSERT INTO app_user (user_id, username, status) VALUES (?, ?, 'ACTIVE')",
            count + 1, name
        );
    }
}

@Service
public class OrderService {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    // 错误：未设置 timeout，死锁时连接永远不释放
    @Transactional
    public void createOrderWithInventoryCheck(int productId) {
        // 1. 先锁库存表
        jdbcTemplate.update("UPDATE inventory SET ... WHERE product_id = ?", productId);

        // 2. 再锁订单表（与另一个事务的加锁顺序相反，形成死锁）
        jdbcTemplate.update("INSERT INTO orders ...");
    }
}

@Transactional(timeout = 10)  // 10 秒内必须完成，快速失败
public void createOrderWithInventoryCheck(int productId) {
    // 统一加锁顺序：先订单表，后库存表，避免循环等待
    jdbcTemplate.update("INSERT INTO orders ...");
    jdbcTemplate.update("UPDATE inventory SET ... WHERE product_id = ?", productId);
}