在Payara环境的Java EE项目中，如何为循环处理的每个Position对象开启独立事务/会话

看起来你遇到的问题核心是：整个processPositions方法默认跑在同一个事务里，一旦某个Position处理失败导致事务回滚，这个事务就会被标记为rollback-only，后续循环的操作都会因为这个废弃的事务直接抛出EJBTransactionRolledbackException。要实现每个Position的操作独立成一个事务（失败不影响其他Position），在Java EE + Payara的环境里有两种非常实用的方案，结合你的Hibernate/JPA场景，我给你详细说明：

方案1：抽离单个Position处理为独立EJB方法（推荐，容器自动管理事务） #

Java EE的EJB容器提供了事务注解来控制事务范围，我们可以把单个Position的处理逻辑抽成独立的EJB方法，并给它加上@TransactionAttribute(TransactionAttributeType.REQUIRES_NEW)注解。这个注解的作用是：每次调用该方法时，不管当前有没有事务，都会强制开启一个全新的独立事务——之前的事务会被暂时挂起，当前方法的事务成功就提交，失败就回滚，完全不影响后续的调用。

代码示例 #

首先创建一个专门处理单个Position的EJB：

import javax.ejb.Stateless;
import javax.ejb.TransactionAttribute;
import javax.ejb.TransactionAttributeType;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

@Stateless
public class PositionProcessorEJB {

    @PersistenceContext // 容器管理的EntityManager，自动绑定到当前事务
    private EntityManager em;

    // 关键注解：每次调用都开启新事务
    @TransactionAttribute(TransactionAttributeType.REQUIRES_NEW)
    public void processSinglePosition(Position position) {
        try {
            // 这里放单个Position对应的所有处理逻辑（原来循环里的内层代码）
            for(Trade trade : getBorrowTradesForPosition(position)) { // 注意：要根据当前position获取对应的trades
                for(TradeEvent event : getFutureEventsForTrade(trade)) {
                    cancelEvent(event);
                    em.merge(event); // 修改后的对象需要merge到持久化上下文
                }
                closeTrade(trade);
                em.merge(trade);
            }
            // 如果Position本身有修改，也要同步到上下文
            em.merge(position);
        } catch (Exception e) {
            // 这里的异常会触发当前独立事务的回滚，然后抛出给外层循环处理
            throw new RuntimeException("处理Position [" + position.getId() + "] 失败", e);
        }
    }

    // 辅助方法：根据position获取对应的borrowTrades（你需要自己实现逻辑）
    private List<Trade> getBorrowTradesForPosition(Position position) {
        // 比如用EntityManager查询关联的Trade
        return em.createQuery("SELECT t FROM Trade t WHERE t.position = :pos", Trade.class)
                 .setParameter("pos", position)
                 .getResultList();
    }

    // 同理实现getFutureEventsForTrade方法
}

然后修改原来的processPositions方法，循环调用这个独立的EJB方法：

import javax.ejb.EJB;
import javax.ejb.Stateless;

@Stateless
public class PositionService {

    @EJB // 注入刚才创建的EJB（必须通过容器代理，不能自己new！）
    private PositionProcessorEJB positionProcessor;

    public void processPositions() {
        for(Position position : shortPositions) {
            try {
                // 每个Position调用独立的事务方法
                positionProcessor.processSinglePosition(position);
            } catch (Exception e) {
                // 捕获单个Position的处理异常，记录日志后继续下一个
                System.err.println("处理Position [" + position.getId() + "] 失败，已跳过：" + e.getMessage());
                // 这里可以加日志框架的记录，比如logger.error(...)
            }
        }
    }
}

关键注意事项 #

• 必须通过EJB容器注入PositionProcessorEJB，不能手动new实例——事务注解是容器通过代理实现的，自己new的对象不会触发容器的事务管理。
• 每个processSinglePosition方法的事务是完全独立的：成功就提交当前Position的所有修改，失败就回滚，不会影响其他Position的处理。

方案2：手动管理事务（UserTransaction） #

如果你更习惯像原生SQL那样手动控制事务的开启/提交/回滚，可以用Java EE提供的UserTransaction接口，直接在循环里为每个Position手动管理事务生命周期。

代码示例 #

import javax.annotation.Resource;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.transaction.Status;
import javax.transaction.UserTransaction;

@Stateless
public class PositionService {

    @PersistenceContext
    private EntityManager em;

    @Resource // 注入容器管理的UserTransaction
    private UserTransaction utx;

    public void processPositions() {
        for(Position position : shortPositions) {
            try {
                // 为当前Position开启新事务
                utx.begin();

                // 处理当前Position的所有逻辑（和原来的内层代码一致）
                for(Trade trade : getBorrowTradesForPosition(position)) {
                    for(TradeEvent event : getFutureEventsForTrade(trade)) {
                        cancelEvent(event);
                        em.merge(event);
                    }
                    closeTrade(trade);
                    em.merge(trade);
                }
                em.merge(position);

                // 提交事务：保存当前Position的所有修改
                utx.commit();
            } catch (Exception e) {
                // 异常时回滚当前事务
                try {
                    if (utx.getStatus() == Status.STATUS_ACTIVE || utx.getStatus() == Status.STATUS_MARKED_ROLLBACK) {
                        utx.rollback();
                    }
                } catch (Exception rollbackEx) {
                    System.err.println("回滚Position [" + position.getId() + "] 的事务失败：" + rollbackEx.getMessage());
                }
                // 记录异常后继续下一个Position
                System.err.println("处理Position [" + position.getId() + "] 失败，已回滚：" + e.getMessage());
            }
        }
    }

    // 辅助方法：获取当前Position对应的Trade和TradeEvent（和方案1一致）
    private List<Trade> getBorrowTradesForPosition(Position position) {
        return em.createQuery("SELECT t FROM Trade t WHERE t.position = :pos", Trade.class)
                 .setParameter("pos", position)
                 .getResultList();
    }
}

关键注意事项 #

• 手动管理事务时，一定要确保在异常分支里正确回滚事务，避免事务挂起导致资源泄漏。
• Hibernate/JPA的EntityManager是和当前事务绑定的（默认是Transaction-scoped），所以每个新事务都会自动关联一个干净的持久化上下文，不会和之前的操作产生状态污染。

给Hibernate新手的额外提示 #

你之前提到“没有Hibernate时会手动开新事务”，其实JPA/Hibernate并没有完全隐藏事务逻辑，只是容器帮你做了默认的事务绑定：

• 容器管理的EntityManager默认是Transaction-scoped：每个事务对应一个独立的持久化上下文，事务结束后上下文会被容器清理。
• 不管用方案1还是方案2，每个Position的操作都会在全新的持久化上下文里执行，和原生SQL手动开事务的逻辑完全一致，只是JPA帮你做了对象和数据库的映射。

备注：内容来源于stack exchange，提问作者DocU