Hibernate DAO连接未关闭致连接池耗尽问题求助

问题背景 #

我在Heroku上部署了一个用Hibernate管理单表的Java应用，之前因Eclipse-Link出问题转用Hibernate，跟着hibernate-jpa-dao-example教程实现DAO。但运行后少量请求就耗尽了20个连接池资源，应用直接无响应，甚至CLI都连不上——同一个客户端发3次请求就占3个连接，报错：

SEVERE: Connection error: org.postgresql.util.PSQLException: FATAL: too many connections for role "fjodybratyjsdp"

核心问题分析 #

看你的DAO和配置，主要有三个致命问题：

• SessionFactory重复创建：getSessionFactory()每次调用都会新建SessionFactory！Hibernate的SessionFactory是重量级全局对象，每次请求新建会导致每个Factory维护独立连接池，20个连接的配置被多次实例化，瞬间耗尽数据库连接。
• 单例DAO的线程安全漏洞：ParksDAO是单例，但currentSession和currentTransaction是实例变量，多线程下会被不同请求覆盖，导致部分连接永远无法关闭，直接泄漏。
• 异常场景下连接未回收：代码没有处理异常，比如事务操作抛出异常时，closeCurrentSessionwithTransaction()直接commit，会导致session未关闭，连接被占用。

修正后的代码 #

1. 修复ParksDAO（解决SessionFactory单例+线程安全+异常处理） #

public class ParksDAO { 
    private static final String HIBERNATE_CFG_XML = "hibernateAPP1.cfg.xml"; 
    private static ParksDAO instance; 
    // 全局唯一的SessionFactory，只初始化一次
    private static SessionFactory sessionFactory; 

    private ParksDAO() { } 

    public static ParksDAO getInstance() { 
        // 双重检查锁实现线程安全的单例
        if (instance == null) { 
            synchronized (ParksDAO.class) {
                if (instance == null) {
                    instance = new ParksDAO();
                    sessionFactory = getSessionFactory();
                }
            }
        } 
        return instance; 
    } 

    // 提供独立的session获取方法，避免全局session变量的线程安全问题
    public Session openSession() { 
        return sessionFactory.openSession(); 
    } 

    // 封装事务操作，自动处理commit/rollback和session关闭
    public <T> T executeInTransaction(SessionCallback<T> callback) {
        Session session = null;
        Transaction tx = null;
        try {
            session = sessionFactory.openSession();
            tx = session.beginTransaction();
            T result = callback.execute(session);
            tx.commit();
            return result;
        } catch (Exception e) {
            if (tx != null && tx.isActive()) {
                tx.rollback();
            }
            throw new RuntimeException("数据库事务执行失败", e);
        } finally {
            if (session != null && session.isOpen()) {
                session.close();
            }
        }
    }

    // 回调接口，封装具体数据库操作逻辑
    public interface SessionCallback<T> {
        T execute(Session session);
    }

    private static SessionFactory getSessionFactory() { 
        Configuration configuration = new Configuration().configure(HIBERNATE_CFG_XML); 
        configuration.addAnnotatedClass(Park.class); 
        StandardServiceRegistryBuilder builder = new StandardServiceRegistryBuilder() 
                .applySettings(configuration.getProperties()); 
        return configuration.buildSessionFactory(builder.build()); 
    } 

    // 移除原有的currentSession、currentTransaction相关全局变量和方法
}

2. 修复ParkPersistencyService（简化调用，确保连接回收） #

public class ParkPersistencyService { 
    private static final ParksDAO parkDAO = ParksDAO.getInstance(); 

    public static Park savePark(Park entity) { 
        return parkDAO.executeInTransaction(session -> {
            session.save(entity);
            return entity;
        });
    } 

    public static Park updatePark(Park entity) { 
        return parkDAO.executeInTransaction(session -> {
            return (Park) session.merge(entity);
        });
    } 

    public static void removePark(Park p) { 
        parkDAO.executeInTransaction(session -> {
            session.delete(p);
            return null;
        });
    } 

    public static Park getParkById(int id) { 
        // 查询操作无需事务，用try-with-resources自动关闭session
        try (Session session = parkDAO.openSession()) {
            return session.get(Park.class, id);
        }
    } 

    public static List<Park> getAllParks() { 
        try (Session session = parkDAO.openSession()) {
            return session.createQuery("from Park", Park.class).list();
        }
    } 
}

3. 优化hibernate配置（适配Heroku环境） #

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-configuration SYSTEM "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <property name="hibernate.dialect">org.hibernate.dialect.PostgreSQLDialect</property>
        <property name="hibernate.connection.driver_class">org.postgresql.Driver</property>
        <!-- 从Heroku环境变量读取数据库信息，避免硬编码 -->
        <property name="hibernate.connection.url">${JDBC_DATABASE_URL}</property>
        <property name="hibernate.connection.username">${JDBC_DATABASE_USERNAME}</property>
        <property name="hibernate.connection.password">${JDBC_DATABASE_PASSWORD}</property>
        <property name="hibernate.hbm2ddl.auto">update</property>
        <property name="show_sql">false</property>
        <!-- 移除thread上下文配置，改用手动session管理 -->
        <!-- <property name="hibernate.current_session_context_class">thread</property> -->
        <!-- Heroku Postgres连接数有限，调小连接池到合理范围 -->
        <property name="connection.pool_size">5</property>
        <!-- 配置连接超时，自动回收闲置连接 -->
        <property name="hibernate.c3p0.timeout">1800</property>
        <property name="hibernate.c3p0.max_statements">50</property>
    </session-factory>
</hibernate-configuration>

额外优化建议 #

• 引入C3P0连接池：Hibernate自带连接池功能基础，添加C3P0依赖可以配置更完善的连接回收策略（比如最大闲置时间、连接测试等），进一步避免泄漏。
• 监控连接状态：在Heroku用heroku pg:info查看数据库连接使用情况，或者引入Micrometer等工具跟踪连接池指标。
• 避免长连接：所有数据库操作必须确保session及时关闭，try-with-resources是最安全的实现方式。

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