多Spring @Transactional注解下Quartz批处理的Hibernate Session管理

嘿，这个问题我太熟悉了！之前用Quartz做批处理和Hibernate整合的时候，也踩过这个延迟加载的坑。下面给你几个实用的解决方案，你可以根据自己的业务场景来选：

这个方法的核心是在Job执行的整个周期内手动打开并绑定Hibernate会话，直到所有延迟加载对象处理完成后再关闭。适合需要严格控制会话时机的场景。

你可以写一个抽象基类，让所有需要处理延迟加载的Job继承它：

public abstract class HibernateAwareJob implements Job {
    @Autowired
    private SessionFactory sessionFactory;

    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        Session session = sessionFactory.openSession();
        // 将会话绑定到当前线程，让Hibernate能找到它
        TransactionSynchronizationManager.bindResource(sessionFactory, new SessionHolder(session));
        
        try {
            // 第一步：执行你的核心业务逻辑（包括提交事务）
            doCoreBusiness(context);
            
            // 第二步：处理需要访问延迟加载对象的逻辑，此时会话还活跃
            processLazyLoadedData();
        } finally {
            // 无论成功失败，都要解绑并关闭会话，避免资源泄漏
            TransactionSynchronizationManager.unbindResource(sessionFactory);
            session.close();
        }
    }

    // 子类实现核心业务逻辑
    protected abstract void doCoreBusiness(JobExecutionContext context) throws JobExecutionException;
    // 子类实现延迟加载对象的处理逻辑
    protected abstract void processLazyLoadedData();
}

注意：一定要在finally块里关闭会话，否则会导致数据库连接泄漏！

如果不想每个Job都写重复的会话管理代码，可以用Spring AOP做一个切面，自动在Job执行前后打开/关闭会话。

首先定义一个自定义注解：

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface OpenSessionInJob {
}

然后写一个AOP切面：

@Aspect
@Component
public class QuartzSessionAspect {
    @Autowired
    private SessionFactory sessionFactory;

    @Around("execution(* org.quartz.Job.execute(..)) && @annotation(OpenSessionInJob)")
    public Object wrapJobWithSession(ProceedingJoinPoint joinPoint) throws Throwable {
        Session session = sessionFactory.openSession();
        SessionHolder sessionHolder = new SessionHolder(session);
        TransactionSynchronizationManager.bindResource(sessionFactory, sessionHolder);
        
        try {
            // 执行Job的核心逻辑
            return joinPoint.proceed();
        } finally {
            TransactionSynchronizationManager.unbindResource(sessionFactory);
            session.close();
        }
    }
}

最后在你的Job类的execute方法上加上@OpenSessionInJob注解就行，这样切面会自动帮你管理会话生命周期，代码更简洁。

其实Hibernate的延迟加载异常本质是「会话关闭后访问未初始化的代理对象」，如果能在事务提交前就把需要的对象初始化好，根本不需要保持会话活跃。这也是更符合Hibernate最佳实践的方式（会话应该尽可能短）。

有两种常用方式：

• 在查询时用Fetch Join：比如在JPQL或Criteria查询里直接关联加载需要的延迟字段，避免后续延迟加载。

  @Transactional
  public List<User> getUsersForEmail() {
      // 用fetch join一次性加载用户和关联的邮箱配置
      return entityManager.createQuery(
          "SELECT u FROM User u JOIN FETCH u.emailConfig WHERE u.status = :status", User.class)
          .setParameter("status", Status.TO_NOTIFY)
          .getResultList();
  }
  

• 手动初始化对象：如果已经拿到了实体对象，用Hibernate.initialize()强制初始化延迟字段。

  @Transactional
  public void prepareUserForEmail(User user) {
      // 提前初始化延迟加载的邮箱配置
      Hibernate.initialize(user.getEmailConfig());
      // 提交事务后，即使会话关闭，也能访问user.getEmailConfig()
  }
  

这个方案的优点是不用额外管理会话，避免了长会话带来的资源占用问题；缺点是如果需要加载的延迟对象太多，可能会影响查询性能，需要权衡。

如果你的批处理任务数据量不大、执行时间短，可以直接把整个Job的执行逻辑放在同一个事务里，这样会话会一直活跃到事务结束。

只需要在execute方法上加上@Transactional注解（注意设置传播属性为REQUIRES_NEW，避免和Quartz的上下文事务冲突）：

@Component
public class UserUpdateJob implements Job {
    @Autowired
    private UserService userService;

    @Override
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void execute(JobExecutionContext context) throws JobExecutionException {
        // 更新用户数据（事务内执行）
        userService.updateBatchUserData();
        // 发送邮件，此时可以访问延迟加载对象（事务还未提交，会话活跃）
        userService.sendEmailsToQualifiedUsers();
    }
}

注意：如果批处理数据量很大，长时间的事务会占用数据库连接，甚至触发事务超时，这种场景下不建议用这个方案。

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