Spring中事务与持久化操作常见陷阱及规避指南

@service
public class orderservice {
    
    // ❌ 错误：内部调用不走 spring 代理，@transactional 不生效
    public void createorder(order order) {
        this.saveorder(order);  // 直接调用，不经过代理
    }
    
    @transactional
    public void saveorder(order order) {
        orderrepository.save(order);  // 这里没有事务保护！
    }
}

// 方案1：注入自身（推荐）
@service
public class orderservice {
    @resource
    private orderservice self;  // 注入代理对象
    
    public void createorder(order order) {
        self.saveorder(order);  // 通过代理调用，事务生效
    }
    
    @transactional
    public void saveorder(order order) {
        orderrepository.save(order);
    }
}

// 方案2：拆分到另一个 service
@service
public class orderservice {
    @resource
    private ordertransactionservice txservice;
    
    public void createorder(order order) {
        txservice.saveorder(order);  // 不同类的调用走代理
    }
}

// 方案3：直接在外部方法加事务
@service
public class orderservice {
    @transactional  // 直接加在入口方法
    public void createorder(order order) {
        orderrepository.save(order);
    }
}

@transactional
public void outermethod() {
    orderrepository.save(order);  // 外层事务
    
    try {
        self.innermethod();  // 内层新事务
    } catch (exception e) {
        // 即使内层回滚，外层可以继续
        log.warn("内层失败", e);
    }
    
    // 外层继续执行...
}

@transactional(propagation = propagation.requires_new)
public void innermethod() {
    logrepository.save(log);  // 独立事务
    throw new runtimeexception("失败");  // 内层回滚，不影响外层
}

// ❌ 陷阱：requires_new 内查不到外层未提交的数据
@transactional
public void outermethod() {
    order order = new order();
    orderrepository.save(order);  // 外层事务中，还没 commit
    
    self.checkorder(order.getid());  // 新事务中查不到这条数据！
}

@transactional(propagation = propagation.requires_new)
public void checkorder(integer orderid) {
    order order = orderrepository.findbyid(orderid).orelse(null);
    // order == null！因为外层事务还没提交
}

// 默认只有 runtimeexception 和 error 触发回滚
@transactional  // = @transactional(rollbackfor = runtimeexception.class)
public void method() {
    throw new ioexception("文件错误");  // ❌ 不回滚！checked exception
    throw new runtimeexception("运行时错误");  // ✅ 回滚
}

// ✅ 正确：明确指定 rollbackfor
@transactional(rollbackfor = exception.class)
public void method() {
    throw new ioexception("文件错误");  // ✅ 回滚
}

// ❌ 陷阱：虽然 catch 了，但 spring 已标记事务为 rollback-only
@transactional
public void outermethod() {
    try {
        self.innermethod();  // 抛异常
    } catch (exception e) {
        log.warn("忽略异常");
        // 以为事务还能继续...
    }
    orderrepository.save(order);  // 事务提交时报错：
    // transaction silently rolled back because it has been marked as rollback-only
}

@transactional  // 默认 required，加入外层事务
public void innermethod() {
    throw new runtimeexception("失败");
    // spring 将共享的事务标记为 rollback-only
}

// ❌ 报错：no transaction is in progress
aftercommit() {
    repository.saveandflush(entity);
}

// ✅ 正确：用 save
aftercommit() {
    repository.save(entity);
}

// ❌ 陷阱：aftercommit 中持久化上下文可能已关闭
@transactional
public void method() {
    user user = userrepository.findbyid(1).get();  // 托管态
    
    aftercommit(() -> {
        // 此时 user 可能已变为游离态
        user.getorders();  // lazyinitializationexception（如果是懒加载）
    });
}

// ✅ 正确：在 aftercommit 中重新查询
aftercommit(() -> {
    user user = userrepository.findbyid(1).get();  // 新的持久化上下文
    user.getorders();  // ok
});

@transactional
public void createorder(order order) {
    orderrepository.save(order);  // 主事务
    
    aftercommit(() -> {
        // 即使这里报错，订单已经提交成功了
        notifyservice.send(order.getid());  // 失败不影响订单
    });
}
// aftercommit 的异常不会导致主事务回滚（因为已经提交了）
// 但如果不 catch，异常会向上抛出（可能影响 mq ack 等）

// ❌ 错误顺序：签收后出库单变为已完成，拒收被幂等跳过
public void partialsignandreject() {
    confirmsign();        // 出库单状态 → 7（已完成）
    csgcreject();         // 检测到状态=7 → 跳过 ❌
}

// ✅ 正确顺序：先拒收再签收
public void partialsignandreject() {
    csgcreject();         // 出库单还是5 → 正常执行拒收
    confirmsign();        // 最后签收 → 出库单状态 → 7
}

@transactional
public void updateandcheck() {
    outbounddetail detail = detailrepository.findbyid(1).get();
    detail.setrejectedqty(2);
    detailrepository.saveandflush(detail);  // 立即写入db
    
    // 注意：此时 detail 对象的 version 字段已被 hibernate 更新
    // 如果后续再 save 一次，version 是新的，不会冲突
    
    // 但如果另一个线程同时修改了这条记录：
    detail.setrejectedqty(3);
    detailrepository.saveandflush(detail);  // 可能 optimisticlockexception
}

@transactional
public void example() {
    user user = userrepository.findbyid(1).get();  // 托管态
    user.setname("新名字");  // 直接修改，不需要调 save！
    
    // 事务提交时，hibernate 脏检查发现 name 变了
    // 自动生成 update sql
    // 不需要手动 save/saveandflush
}

// 但如果不在事务中：
public void notransaction() {
    user user = userrepository.findbyid(1).get();  // 游离态（事务结束了）
    user.setname("新名字");  // 修改不会被追踪
    // 必须手动 save
    userrepository.save(user);
}

// ❌ 10万条数据全部加载到持久化上下文，内存爆
@transactional
public void batchupdate() {
    list<user> users = userrepository.findall();  // 10万条全在内存
    for (user user : users) {
        user.setstatus(1);
    }
    // commit 时 flush 10万条 update
}

// ✅ 分批处理 + 定期清理持久化上下文
@transactional
public void batchupdate() {
    int page = 0;
    page<user> users;
    do {
        users = userrepository.findall(pagerequest.of(page++, 1000));
        for (user user : users) {
            user.setstatus(1);
        }
        userrepository.flush();           // 执行 sql
        entitymanager.clear();             // 清理持久化上下文释放内存
    } while (users.hasnext());
}

// ❌ jpa persist 后还没 flush，mybatis 直接查数据库查不到
@transactional
public void mixed() {
    user user = new user();
    user.setname("张三");
    userrepository.save(user);  // 只在持久化上下文中，还没 flush
    
    // mybatis 直接执行 sql 查数据库
    user found = usermapper.selectbyid(user.getid());
    // found == null！因为 jpa 还没把 insert 发到数据库
}

// ✅ 先 flush 再用 mybatis 查
@transactional
public void mixed() {
    user user = new user();
    userrepository.save(user);
    entitymanager.flush();  // 强制把 insert 发到数据库
    
    user found = usermapper.selectbyid(user.getid());  // 能查到了
}

// ❌ mybatis 直接改了 db，但 jpa 持久化上下文中还是旧值
@transactional
public void mixed() {
    user user = userrepository.findbyid(1).get();  // name="张三"，缓存在持久化上下文
    
    usermapper.updatename(1, "李四");  // mybatis 直接 update 数据库
    
    user found = userrepository.findbyid(1).get();  // 还是"张三"！
    // jpa 一级缓存返回了持久化上下文中的旧对象
}

// ✅ mybatis 修改后清理 jpa 缓存
@transactional
public void mixed() {
    user user = userrepository.findbyid(1).get();
    
    usermapper.updatename(1, "李四");
    entitymanager.clear();  // 清理持久化上下文缓存
    
    user found = userrepository.findbyid(1).get();  // "李四" ✅
}

# 确保 jpa 和 mybatis 使用同一个事务管理器和数据源
spring:
  datasource:
    url: jdbc:mysql://...
  jpa:
    hibernate:
      ddl-auto: none
# mybatis 默认使用 spring 管理的 datasource，与 jpa 共享事务

// ❌ 两次数据库操作之间有时间窗口，可能被别人修改
public void deductstock(integer skuid, integer qty) {
    stock stock = stockrepository.findbyid(skuid).get();  // version=1
    
    // ... 这里可能经过了几秒（比如调了远程服务）
    
    stock.setquantity(stock.getquantity() - qty);
    stockrepository.save(stock);  // version=1 → update where version=1
    // 如果别人先改了（version变成2），这里 optimisticlockexception
}

// ✅ 捕获乐观锁异常并重试
@retryable(value = optimisticlockexception.class, maxattempts = 3)
@transactional
public void deductstock(integer skuid, integer qty) {
    stock stock = stockrepository.findbyid(skuid).get();
    stock.setquantity(stock.getquantity() - qty);
    stockrepository.save(stock);
}

@transactional
public void update() {
    user user = userrepository.findbyid(1).get();  // version=5
    user.setname("新名字");
    
    // saveandflush 立即执行 update，立即知道是否冲突
    userrepository.saveandflush(user);  // 如果冲突立即抛 optimisticlockexception
    
    // 而 save 延迟到 commit 时才知道冲突
    userrepository.save(user);  // 要到事务提交时才报错
}

// ❌ 事件监听者在事务提交前执行，可能看到不一致状态
@transactional
public void createorder(order order) {
    orderrepository.save(order);
    eventpublisher.publishevent(new ordercreatedevent(order.getid()));
    // 监听者此时能查到 order（同一事务），但如果事务回滚就不一致了
}

// ✅ 使用 @transactionaleventlistener 确保事务提交后再处理
@transactionaleventlistener(phase = transactionphase.after_commit)
public void handleordercreated(ordercreatedevent event) {
    // 只在事务成功提交后才执行
    notifyservice.send(event.getorderid());
}

// ❌ 事务内发 mq，如果事务回滚消息已发出
@transactional
public void createorder(order order) {
    orderrepository.save(order);
    mqsender.send("order.created", order.getid());  // mq 已发
    
    validateorder(order);  // 如果这里抛异常 → 事务回滚 → 但 mq 已发
}

// ✅ aftercommit 中发 mq
@transactional
public void createorder(order order) {
    orderrepository.save(order);
    
    transactionsynchronizationmanager.registersynchronization(
        new transactionsynchronization() {
            @override
            public void aftercommit() {
                mqsender.send("order.created", order.getid());
            }
        }
    );
}

// ❌ 远程调用放在事务内：长事务 + 锁持有时间长
@transactional
public void process() {
    stock stock = stockrepository.findforupdate(skuid);  // 行锁
    stock.setquantity(stock.getquantity() - 1);
    
    // 远程调用耗时 3 秒 → 行锁持有 3 秒 → 其他线程全部等待
    orderfeign.notifyorderservice(orderid);  // 慢！
    
    stockrepository.save(stock);
}

// ✅ 远程调用放在事务外（或事务提交后）
@transactional
public void process() {
    stock stock = stockrepository.findforupdate(skuid);
    stock.setquantity(stock.getquantity() - 1);
    stockrepository.save(stock);
    // 事务尽快提交，释放锁
}
// 事务提交后再调远程
public void processandnotify() {
    process();  // 事务结束
    orderfeign.notifyorderservice(orderid);  // 不持有锁了
}

// 1. 统一事务注解模板
@transactional(rollbackfor = exception.class)

// 2. 需要新事务的场景
@transactional(propagation = propagation.requires_new, rollbackfor = exception.class)

// 3. aftercommit 中的数据库操作统一用 save
repository.save(entity);  // 不用 saveandflush

// 4. aftercommit 统一 try-catch
aftercommit(() -> {
    try {
        dosomething();
    } catch (exception e) {
        log.warn("aftercommit异常", e);
    }
});

// 5. jpa 和 mybatis 混用时显式 flush
entitymanager.flush();  // jpa 操作后，mybatis 操作前

// 6. 事务尽量短：先准备数据，再开事务
public void process() {
    data data = preparedata();           // 事务外：查询、远程调用
    transactionservice.save(data);       // 事务内：只做写入
    afteraction();                       // 事务外：通知、mq
}

// ❌ 事务内做耗时操作，长时间占用数据库连接
@transactional
public void exportreport() {
    list<order> orders = orderrepository.findall();  // 获取连接
    
    // 组装 excel 耗时 30 秒...
    byte[] excel = buildexcel(orders);
    
    // 上传 oss 耗时 10 秒...
    ossclient.upload(excel);
    
    // 整个过程数据库连接被占用 40 秒
    // 连接池默认 10 个连接，4 个这样的请求就把连接池打满
}

// ✅ 只在需要数据库操作时才开事务
public void exportreport() {
    list<order> orders = queryorders();    // 事务内，快速完成
    byte[] excel = buildexcel(orders);     // 事务外，不占连接
    ossclient.upload(excel);              // 事务外
}

@transactional(readonly = true)
public list<order> queryorders() {
    return orderrepository.findall();
}

// 设置事务超时时间（秒）
@transactional(timeout = 30, rollbackfor = exception.class)
public void process() {
    // 如果 30 秒内没完成，自动回滚
    // 抛出 transactiontimedoutexception
}
# 全局默认超时
spring:
  transaction:
    default-timeout: 60  # 秒

# hikaricp 连接池泄漏检测
spring:
  datasource:
    hikari:
      leak-detection-threshold: 30000  # 30秒未归还连接则告警
      maximum-pool-size: 20
      connection-timeout: 5000  # 获取连接超时5秒
      
// 泄漏告警日志示例：
warn hikaripool - connection leak detection triggered for connection xxx, 
stack trace follows
java.lang.exception: apparent connection leak detected
    at com.zaxxer.hikari.hikaridatasource.getconnection(...)
    at com.example.orderservice.process(orderservice.java:45)

@transactional(readonly = true)
public list<order> queryorders() {
    return orderrepository.findall();
}

@service
@transactional(readonly = true)  // 类级别默认只读
public class orderqueryservice {
    
    public order getbyid(integer id) {
        return orderrepository.findbyid(id).orelse(null);
    }
    
    public page<order> search(orderquery query) {
        return orderrepository.findall(query.tospec(), query.topageable());
    }
    
    // 需要写操作的方法单独覆盖
    @transactional(rollbackfor = exception.class)
    public void updatestatus(integer id, string status) {
        order order = orderrepository.findbyid(id).get();
        order.setstatus(status);
    }
}

public interface stockrepository extends jparepository<stock, integer> {
    
    // 方式1：@lock 注解
    @lock(lockmodetype.pessimistic_write)
    @query("select s from stock s where s.skuid = :skuid")
    stock findbyskuidforupdate(@param("skuid") integer skuid);
    
    // 方式2：entitymanager
    // stock stock = em.find(stock.class, id, lockmodetype.pessimistic_write);
}

select * from stock where sku_id = ? for update

// ❌ 锁住后做远程调用 → 死等 + 其他线程全阻塞
@transactional
public void deduct() {
    stock stock = stockrepository.findbyskuidforupdate(skuid);  // 加行锁
    orderfeign.checkstock(skuid);  // 远程调用 3 秒 → 行锁持有 3 秒
    stock.setquantity(stock.getquantity() - 1);
}

// ✅ 先做远程调用再加锁
@transactional
public void deduct() {
    orderfeign.checkstock(skuid);  // 先做远程调用
    stock stock = stockrepository.findbyskuidforupdate(skuid);  // 最后加锁
    stock.setquantity(stock.getquantity() - 1);
    // 锁持有时间极短
}

// ❌ 两个线程以不同顺序加锁 → 死锁
// 线程a：锁 stock_1 → 等锁 stock_2
// 线程b：锁 stock_2 → 等锁 stock_1

// ✅ 统一按 id 排序后加锁
@transactional
public void transfer(integer fromid, integer toid) {
    integer firstid = math.min(fromid, toid);
    integer secondid = math.max(fromid, toid);
    
    stock first = stockrepository.findbyskuidforupdate(firstid);
    stock second = stockrepository.findbyskuidforupdate(secondid);
    // 所有线程按同一顺序加锁 → 不会死锁
}

@entity
public class order {
    @onetomany(fetch = fetchtype.lazy, mappedby = "order")
    private list<orderitem> items;  // 懒加载
}

// ❌ 事务/session 结束后访问懒加载属性
public orderdto getorder(integer id) {
    order order = orderrepository.findbyid(id).get();
    // 事务结束，session 关闭
    return todto(order);
}

private orderdto todto(order order) {
    orderdto dto = new orderdto();
    dto.setitems(order.getitems());  // lazyinitializationexception!
    // items 是懒加载代理，session 已关闭无法查询
    return dto;
}

// 方案1：fetch join 查询（推荐）
@query("select o from order o join fetch o.items where o.id = :id")
order findbyidwithitems(@param("id") integer id);

// 方案2：@entitygraph
@entitygraph(attributepaths = {"items"})
optional<order> findbyid(integer id);

// 方案3：在事务内完成所有数据访问
@transactional(readonly = true)
public orderdto getorder(integer id) {
    order order = orderrepository.findbyid(id).get();
    orderdto dto = todto(order);  // 在事务内访问 items，ok
    return dto;
}

// 方案4：dto 投影（最佳性能）
@query("select new com.example.orderdto(o.id, o.code, o.status) from order o where o.id = :id")
orderdto finddtobyid(@param("id") integer id);

@transactional(readonly = true)
public list<orderdto> listorders() {
    list<order> orders = orderrepository.findall();  // 1 次查询
    return orders.stream().map(order -> {
        orderdto dto = new orderdto();
        dto.setitems(order.getitems());  // 每个 order 触发一次查询 → n 次
        return dto;
    }).collect(collectors.tolist());
}
// 总共 1+n 次查询（如果 100 条订单就是 101 次 sql）

// 方案1：join fetch
@query("select distinct o from order o join fetch o.items")
list<order> findallwithitems();  // 1 次 sql 搞定

// 方案2：@batchsize（hibernate 特有）
@entity
public class order {
    @onetomany(mappedby = "order")
    @batchsize(size = 100)  // 每次批量加载 100 条关联数据
    private list<orderitem> items;
}

// 方案3：entitygraph
@entitygraph(attributepaths = {"items"})
list<order> findall();

<!-- ✅ #{} 预编译参数（防sql注入） -->
<select id="findbyid">
    select * from user where id = #{id}
</select>
<!-- 生成：select * from user where id = ? -->
<!-- ⚠️ ${} 字符串拼接（有sql注入风险，只用于表名/列名等） -->
<select id="findall">
    select * from user order by ${sortcolumn} ${sortorder}
</select>
<!-- 生成：select * from user order by name asc -->
<!-- 如果 sortcolumn 是用户输入 → sql注入！ -->

<!-- ❌ 循环调单条 insert -->
<!-- java 代码中 for 循环调 insert 方法 → n 次 sql -->
<!-- ✅ 批量 insert -->
<insert id="batchinsert">
    insert into user (name, age) values
    <foreach collection="list" item="item" separator=",">
        (#{item.name}, #{item.age})
    </foreach>
</insert>
<!-- ✅ 批量 update（mysql） -->
<update id="batchupdate">
    <foreach collection="list" item="item" separator=";">
        update user set name = #{item.name} where id = #{item.id}
    </foreach>
</update>

// 同一个 sqlsession（同一个事务）内，相同查询命中缓存
@transactional
public void example() {
    user user1 = usermapper.selectbyid(1);  // 查数据库
    user user2 = usermapper.selectbyid(1);  // 命中一级缓存，不查库
    // user1 == user2（同一个对象）
    
    usermapper.updatename(1, "新名字");  // update 会清空一级缓存
    
    user user3 = usermapper.selectbyid(1);  // 重新查数据库
    // user3.getname() == "新名字"
}

// mybatis 的 insert 立即执行 sql（不像 jpa 有延迟）
@transactional
public void example() {
    usermapper.insert(user);  // 立即执行 insert sql
    
    // 同一事务内可以立即查到（不需要 flush）
    user found = usermapper.selectbyid(user.getid());  // ✅ 能查到
}