单线程多事务下如何保持EntityManager/Session开启？阻止Spring Data关闭Hibernate Session

我来帮你搞定这两个问题，正好之前在开发Spring命令行应用时踩过类似的懒加载坑，给你分享几个实用的方案：

1. 单个线程多事务中保持EntityManager/Session开启 #

默认情况下，Spring的@Transactional注解会让Session/EntityManager和事务绑定：事务开始时创建或获取Session，事务提交/回滚后立即关闭。如果要在多个独立事务间复用同一个Session，你需要手动控制它的生命周期：

手动管理Hibernate Session #

注入SessionFactory后，手动打开Session，在多个事务中复用，最后记得关闭：

@Autowired
private SessionFactory sessionFactory;

public void processMultiTransactionData() {
    Session session = sessionFactory.openSession();
    try {
        // 第一个事务
        Transaction tx1 = session.beginTransaction();
        // 执行数据库操作：比如保存实体
        session.save(new User("Alice"));
        tx1.commit();

        // 第二个事务，复用同一个Session
        Transaction tx2 = session.beginTransaction();
        User user = session.get(User.class, 1L);
        user.setEmail("alice@example.com");
        tx2.commit();

        // 这里访问懒加载关联不会报错，因为Session还没关闭
        user.getOrders().forEach(order -> System.out.println(order.getId()));
    } catch (Exception e) {
        // 异常时回滚活跃事务
        if (session.getTransaction().isActive()) {
            session.getTransaction().rollback();
        }
        throw new RuntimeException("处理失败", e);
    } finally {
        // 最后一定要关闭Session，释放数据库连接
        session.close();
    }
}

手动管理JPA EntityManager #

如果你用JPA而非原生Hibernate，逻辑类似，通过EntityManagerFactory手动创建EntityManager：

@Autowired
private EntityManagerFactory emf;

public void processMultiTransactionData() {
    EntityManager em = emf.createEntityManager();
    try {
        // 第一个事务
        em.getTransaction().begin();
        em.persist(new Product("Laptop"));
        em.getTransaction().commit();

        // 第二个事务
        em.getTransaction().begin();
        Product product = em.find(Product.class, 1L);
        product.setPrice(999.99);
        em.getTransaction().commit();

        // 访问懒加载属性正常
        product.getReviews().forEach(System.out::println);
    } catch (Exception e) {
        if (em.getTransaction().isActive()) {
            em.getTransaction().rollback();
        }
        throw new RuntimeException("处理失败", e);
    } finally {
        em.close();
    }
}

2. 在@Service中阻止Spring关闭Session（解决LazyLoadingException） #

你的问题根源是：@Transactional方法执行完后Spring会自动关闭Session，导致后续访问懒加载关联时抛出异常。针对命令行应用，推荐这几个方案：

方案一：扩大事务覆盖范围 #

最直接的方法是把所有需要访问懒加载属性的逻辑都放到同一个@Transactional方法里。不要在事务外调用Service方法后再访问懒加载属性，而是把读取数据、处理、写入、懒加载访问的全流程都包裹在事务中：

@Service
public class DataSyncService {

    @Autowired
    private ProductRepository productRepo;
    @Autowired
    private WebServiceClient webClient;

    @Transactional
    public void syncAndProcessData() {
        // 1. 从Web服务拉取数据
        List<ProductDto> dtoList = webClient.fetchProducts();
        // 2. 转换为实体并保存
        List<Product> products = dtoList.stream()
                .map(this::convertToEntity)
                .toList();
        productRepo.saveAll(products);
        // 3. 访问懒加载关联（此时事务未结束，Session仍开启）
        products.forEach(p -> p.getReviews().size());
    }
}

这个方案最简单，适合流程可以被一个事务覆盖的场景。

方案二：手动绑定Session到线程上下文（跨多个事务） #

如果你的流程必须拆分成多个独立事务，但又需要在事务间保持Session开启，可以手动把Session绑定到线程上下文，让Spring Data的Repository复用这个Session：

@Component
public class SessionBinder {

    @Autowired
    private SessionFactory sessionFactory;

    public <T> T withPersistentSession(Supplier<T> action) {
        Session session = sessionFactory.openSession();
        SessionHolder sessionHolder = new SessionHolder(session);
        try {
            // 把Session绑定到当前线程，让Spring Data自动使用它
            TransactionSynchronizationManager.bindResource(sessionFactory, sessionHolder);
            return action.get();
        } finally {
            // 解绑并关闭Session
            TransactionSynchronizationManager.unbindResource(sessionFactory);
            session.close();
        }
    }
}

然后在命令行入口类中调用：

@Autowired
private SessionBinder sessionBinder;
@Autowired
private DataSyncService syncService;

public void run(String... args) {
    sessionBinder.withPersistentSession(() -> {
        // 多个@Transactional方法共用同一个Session
        syncService.firstTransactionalTask();
        syncService.secondTransactionalTask();
        
        // 事务结束后仍能访问懒加载属性
        Product product = syncService.getProductById(1L);
        product.getReviews().forEach(r -> System.out.println(r.getContent()));
        return null;
    });
}

这样，不管单个@Transactional方法是否结束，Session都会一直保持开启，直到withPersistentSession块执行完毕。

注意事项 #

• 手动管理Session时一定要注意线程安全：上面的withPersistentSession已经通过TransactionSynchronizationManager把Session绑定到当前线程，所以是安全的。
• 不要长时间保持Session开启，否则会占用数据库连接资源，处理完业务逻辑后务必关闭。

内容的提问来源于stack exchange，提问作者Gustavo Sousa